# 1 "all-std.cxx" # 1 "" # 1 "" # 1 "/usr/include/stdc-predef.h" 1 3 4 # 1 "" 2 # 1 "all-std.cxx" # 9 "all-std.cxx" # 1 "/usr/include/c++/10/concepts" 1 3 # 35 "/usr/include/c++/10/concepts" 3 # 36 "/usr/include/c++/10/concepts" 3 # 44 "/usr/include/c++/10/concepts" 3 # 1 "/usr/include/c++/10/type_traits" 1 3 # 32 "/usr/include/c++/10/type_traits" 3 # 33 "/usr/include/c++/10/type_traits" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 1 3 # 262 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3 # 262 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3 namespace std { typedef long unsigned int size_t; typedef long int ptrdiff_t; typedef decltype(nullptr) nullptr_t; } # 284 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3 namespace std { inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } } namespace __gnu_cxx { inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } } # 522 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/os_defines.h" 1 3 # 39 "/usr/include/x86_64-linux-gnu/c++/10/bits/os_defines.h" 3 # 1 "/usr/include/features.h" 1 3 4 # 461 "/usr/include/features.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4 # 452 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 453 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 # 454 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4 # 462 "/usr/include/features.h" 2 3 4 # 485 "/usr/include/features.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4 # 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4 # 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4 # 486 "/usr/include/features.h" 2 3 4 # 40 "/usr/include/x86_64-linux-gnu/c++/10/bits/os_defines.h" 2 3 # 523 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 2 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/cpu_defines.h" 1 3 # 526 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 2 3 # 692 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 3 # 1 "/usr/include/c++/10/pstl/pstl_config.h" 1 3 # 693 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++config.h" 2 3 # 39 "/usr/include/c++/10/type_traits" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 56 "/usr/include/c++/10/type_traits" 3 template struct integral_constant { static constexpr _Tp value = __v; typedef _Tp value_type; typedef integral_constant<_Tp, __v> type; constexpr operator value_type() const noexcept { return value; } constexpr value_type operator()() const noexcept { return value; } }; template constexpr _Tp integral_constant<_Tp, __v>::value; typedef integral_constant true_type; typedef integral_constant false_type; template using __bool_constant = integral_constant; template using bool_constant = integral_constant; template struct conditional; template struct __type_identity { using type = _Type; }; template using __type_identity_t = typename __type_identity<_Tp>::type; template struct __or_; template<> struct __or_<> : public false_type { }; template struct __or_<_B1> : public _B1 { }; template struct __or_<_B1, _B2> : public conditional<_B1::value, _B1, _B2>::type { }; template struct __or_<_B1, _B2, _B3, _Bn...> : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type { }; template struct __and_; template<> struct __and_<> : public true_type { }; template struct __and_<_B1> : public _B1 { }; template struct __and_<_B1, _B2> : public conditional<_B1::value, _B2, _B1>::type { }; template struct __and_<_B1, _B2, _B3, _Bn...> : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type { }; template struct __not_ : public __bool_constant { }; template inline constexpr bool __or_v = __or_<_Bn...>::value; template inline constexpr bool __and_v = __and_<_Bn...>::value; template struct conjunction : __and_<_Bn...> { }; template struct disjunction : __or_<_Bn...> { }; template struct negation : __not_<_Pp> { }; template inline constexpr bool conjunction_v = conjunction<_Bn...>::value; template inline constexpr bool disjunction_v = disjunction<_Bn...>::value; template inline constexpr bool negation_v = negation<_Pp>::value; template struct is_reference; template struct is_function; template struct is_void; template struct __is_array_unknown_bounds; template constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) { return {}; } template constexpr typename __or_< is_reference<_NestedType>, is_function<_NestedType>, is_void<_NestedType>, __is_array_unknown_bounds<_NestedType> >::type __is_complete_or_unbounded(_TypeIdentity) { return {}; } template struct __success_type { typedef _Tp type; }; struct __failure_type { }; template struct remove_cv; template using __remove_cv_t = typename remove_cv<_Tp>::type; template struct is_const; template struct __is_void_helper : public false_type { }; template<> struct __is_void_helper : public true_type { }; template struct is_void : public __is_void_helper<__remove_cv_t<_Tp>>::type { }; template struct __is_integral_helper : public false_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; template<> struct __is_integral_helper : public true_type { }; # 364 "/usr/include/c++/10/type_traits" 3 template struct is_integral : public __is_integral_helper<__remove_cv_t<_Tp>>::type { }; template struct __is_floating_point_helper : public false_type { }; template<> struct __is_floating_point_helper : public true_type { }; template<> struct __is_floating_point_helper : public true_type { }; template<> struct __is_floating_point_helper : public true_type { }; # 392 "/usr/include/c++/10/type_traits" 3 template struct is_floating_point : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type { }; template struct is_array : public false_type { }; template struct is_array<_Tp[_Size]> : public true_type { }; template struct is_array<_Tp[]> : public true_type { }; template struct __is_pointer_helper : public false_type { }; template struct __is_pointer_helper<_Tp*> : public true_type { }; template struct is_pointer : public __is_pointer_helper<__remove_cv_t<_Tp>>::type { }; template struct is_lvalue_reference : public false_type { }; template struct is_lvalue_reference<_Tp&> : public true_type { }; template struct is_rvalue_reference : public false_type { }; template struct is_rvalue_reference<_Tp&&> : public true_type { }; template struct __is_member_object_pointer_helper : public false_type { }; template struct __is_member_object_pointer_helper<_Tp _Cp::*> : public __not_>::type { }; template struct is_member_object_pointer : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type { }; template struct __is_member_function_pointer_helper : public false_type { }; template struct __is_member_function_pointer_helper<_Tp _Cp::*> : public is_function<_Tp>::type { }; template struct is_member_function_pointer : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type { }; template struct is_enum : public integral_constant { }; template struct is_union : public integral_constant { }; template struct is_class : public integral_constant { }; template struct is_function : public __bool_constant::value> { }; template struct is_function<_Tp&> : public false_type { }; template struct is_function<_Tp&&> : public false_type { }; template struct __is_null_pointer_helper : public false_type { }; template<> struct __is_null_pointer_helper : public true_type { }; template struct is_null_pointer : public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type { }; template struct __is_nullptr_t : public is_null_pointer<_Tp> { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); template struct is_reference : public __or_, is_rvalue_reference<_Tp>>::type { }; template struct is_arithmetic : public __or_, is_floating_point<_Tp>>::type { }; template struct is_fundamental : public __or_, is_void<_Tp>, is_null_pointer<_Tp>>::type { }; template struct is_object : public __not_<__or_, is_reference<_Tp>, is_void<_Tp>>>::type { }; template struct is_member_pointer; template struct is_scalar : public __or_, is_enum<_Tp>, is_pointer<_Tp>, is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type { }; template struct is_compound : public __not_>::type { }; template struct __is_member_pointer_helper : public false_type { }; template struct __is_member_pointer_helper<_Tp _Cp::*> : public true_type { }; template struct is_member_pointer : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type { }; template struct is_same; template using __is_one_of = __or_...>; template using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, signed char, signed short, signed int, signed long, signed long long # 604 "/usr/include/c++/10/type_traits" 3 >; template using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long # 623 "/usr/include/c++/10/type_traits" 3 >; template using __is_standard_integer = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; template using __void_t = void; template struct __is_referenceable : public false_type { }; template struct __is_referenceable<_Tp, __void_t<_Tp&>> : public true_type { }; template struct is_const : public false_type { }; template struct is_const<_Tp const> : public true_type { }; template struct is_volatile : public false_type { }; template struct is_volatile<_Tp volatile> : public true_type { }; template struct is_trivial : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_copyable : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_standard_layout : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct [[deprecated("use is_standard_layout && is_trivial instead")]] is_pod : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_literal_type : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_empty : public integral_constant { }; template struct is_polymorphic : public integral_constant { }; template struct is_final : public integral_constant { }; template struct is_abstract : public integral_constant { }; template::value> struct __is_signed_helper : public false_type { }; template struct __is_signed_helper<_Tp, true> : public integral_constant { }; template struct is_signed : public __is_signed_helper<_Tp>::type { }; template struct is_unsigned : public __and_, __not_>> { }; # 770 "/usr/include/c++/10/type_traits" 3 template _Up __declval(int); template _Tp __declval(long); template auto declval() noexcept -> decltype(__declval<_Tp>(0)); template struct extent; template struct remove_all_extents; template struct __is_array_known_bounds : public integral_constant::value > 0)> { }; template struct __is_array_unknown_bounds : public __and_, __not_>> { }; struct __do_is_destructible_impl { template().~_Tp())> static true_type __test(int); template static false_type __test(...); }; template struct __is_destructible_impl : public __do_is_destructible_impl { typedef decltype(__test<_Tp>(0)) type; }; template, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_, is_scalar<_Tp>>::value> struct __is_destructible_safe; template struct __is_destructible_safe<_Tp, false, false> : public __is_destructible_impl::type>::type { }; template struct __is_destructible_safe<_Tp, true, false> : public false_type { }; template struct __is_destructible_safe<_Tp, false, true> : public true_type { }; template struct is_destructible : public __is_destructible_safe<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; struct __do_is_nt_destructible_impl { template static __bool_constant().~_Tp())> __test(int); template static false_type __test(...); }; template struct __is_nt_destructible_impl : public __do_is_nt_destructible_impl { typedef decltype(__test<_Tp>(0)) type; }; template, __is_array_unknown_bounds<_Tp>, is_function<_Tp>>::value, bool = __or_, is_scalar<_Tp>>::value> struct __is_nt_destructible_safe; template struct __is_nt_destructible_safe<_Tp, false, false> : public __is_nt_destructible_impl::type>::type { }; template struct __is_nt_destructible_safe<_Tp, true, false> : public false_type { }; template struct __is_nt_destructible_safe<_Tp, false, true> : public true_type { }; template struct is_nothrow_destructible : public __is_nt_destructible_safe<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct __is_constructible_impl : public __bool_constant<__is_constructible(_Tp, _Args...)> { }; template struct is_constructible : public __is_constructible_impl<_Tp, _Args...> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_default_constructible : public __is_constructible_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_copy_constructible_impl; template struct __is_copy_constructible_impl<_Tp, false> : public false_type { }; template struct __is_copy_constructible_impl<_Tp, true> : public __is_constructible_impl<_Tp, const _Tp&> { }; template struct is_copy_constructible : public __is_copy_constructible_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_move_constructible_impl; template struct __is_move_constructible_impl<_Tp, false> : public false_type { }; template struct __is_move_constructible_impl<_Tp, true> : public __is_constructible_impl<_Tp, _Tp&&> { }; template struct is_move_constructible : public __is_move_constructible_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct __is_nt_constructible_impl : public false_type { }; template struct __is_nt_constructible_impl : public __bool_constant()...))> { }; template struct __is_nt_constructible_impl : public __bool_constant(std::declval<_Arg>()))> { }; template struct __is_nt_constructible_impl : public __bool_constant { }; template struct __is_nt_constructible_impl : public __bool_constant::type())> { }; template struct __is_nt_constructible_impl : public __is_nt_constructible_impl { }; template struct __is_nt_constructible_impl : public __and_<__is_nt_constructible_impl...> { }; template using __is_nothrow_constructible_impl = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...), _Tp, _Args...>; template struct is_nothrow_constructible : public __is_nothrow_constructible_impl<_Tp, _Args...>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_default_constructible : public __is_nothrow_constructible_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_nothrow_copy_constructible_impl; template struct __is_nothrow_copy_constructible_impl<_Tp, false> : public false_type { }; template struct __is_nothrow_copy_constructible_impl<_Tp, true> : public __is_nothrow_constructible_impl<_Tp, const _Tp&> { }; template struct is_nothrow_copy_constructible : public __is_nothrow_copy_constructible_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_nothrow_move_constructible_impl; template struct __is_nothrow_move_constructible_impl<_Tp, false> : public false_type { }; template struct __is_nothrow_move_constructible_impl<_Tp, true> : public __is_nothrow_constructible_impl<_Tp, _Tp&&> { }; template struct is_nothrow_move_constructible : public __is_nothrow_move_constructible_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_assignable : public __bool_constant<__is_assignable(_Tp, _Up)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_copy_assignable_impl; template struct __is_copy_assignable_impl<_Tp, false> : public false_type { }; template struct __is_copy_assignable_impl<_Tp, true> : public __bool_constant<__is_assignable(_Tp&, const _Tp&)> { }; template struct is_copy_assignable : public __is_copy_assignable_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_move_assignable_impl; template struct __is_move_assignable_impl<_Tp, false> : public false_type { }; template struct __is_move_assignable_impl<_Tp, true> : public __bool_constant<__is_assignable(_Tp&, _Tp&&)> { }; template struct is_move_assignable : public __is_move_assignable_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct __is_nt_assignable_impl : public integral_constant() = declval<_Up>())> { }; template struct __is_nothrow_assignable_impl : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>, __is_nt_assignable_impl<_Tp, _Up>> { }; template struct is_nothrow_assignable : public __is_nothrow_assignable_impl<_Tp, _Up> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_nt_copy_assignable_impl; template struct __is_nt_copy_assignable_impl<_Tp, false> : public false_type { }; template struct __is_nt_copy_assignable_impl<_Tp, true> : public __is_nothrow_assignable_impl<_Tp&, const _Tp&> { }; template struct is_nothrow_copy_assignable : public __is_nt_copy_assignable_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_nt_move_assignable_impl; template struct __is_nt_move_assignable_impl<_Tp, false> : public false_type { }; template struct __is_nt_move_assignable_impl<_Tp, true> : public __is_nothrow_assignable_impl<_Tp&, _Tp&&> { }; template struct is_nothrow_move_assignable : public __is_nt_move_assignable_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_constructible : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_default_constructible : public __bool_constant<__is_trivially_constructible(_Tp)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; struct __do_is_implicitly_default_constructible_impl { template static void __helper(const _Tp&); template static true_type __test(const _Tp&, decltype(__helper({}))* = 0); static false_type __test(...); }; template struct __is_implicitly_default_constructible_impl : public __do_is_implicitly_default_constructible_impl { typedef decltype(__test(declval<_Tp>())) type; }; template struct __is_implicitly_default_constructible_safe : public __is_implicitly_default_constructible_impl<_Tp>::type { }; template struct __is_implicitly_default_constructible : public __and_<__is_constructible_impl<_Tp>, __is_implicitly_default_constructible_safe<_Tp>> { }; template::value> struct __is_trivially_copy_constructible_impl; template struct __is_trivially_copy_constructible_impl<_Tp, false> : public false_type { }; template struct __is_trivially_copy_constructible_impl<_Tp, true> : public __and_<__is_copy_constructible_impl<_Tp>, integral_constant> { }; template struct is_trivially_copy_constructible : public __is_trivially_copy_constructible_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_trivially_move_constructible_impl; template struct __is_trivially_move_constructible_impl<_Tp, false> : public false_type { }; template struct __is_trivially_move_constructible_impl<_Tp, true> : public __and_<__is_move_constructible_impl<_Tp>, integral_constant> { }; template struct is_trivially_move_constructible : public __is_trivially_move_constructible_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_assignable : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_trivially_copy_assignable_impl; template struct __is_trivially_copy_assignable_impl<_Tp, false> : public false_type { }; template struct __is_trivially_copy_assignable_impl<_Tp, true> : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)> { }; template struct is_trivially_copy_assignable : public __is_trivially_copy_assignable_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template::value> struct __is_trivially_move_assignable_impl; template struct __is_trivially_move_assignable_impl<_Tp, false> : public false_type { }; template struct __is_trivially_move_assignable_impl<_Tp, true> : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)> { }; template struct is_trivially_move_assignable : public __is_trivially_move_assignable_impl<_Tp> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_trivially_destructible : public __and_<__is_destructible_safe<_Tp>, __bool_constant<__has_trivial_destructor(_Tp)>> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct has_virtual_destructor : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct alignment_of : public integral_constant { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct rank : public integral_constant { }; template struct rank<_Tp[_Size]> : public integral_constant::value> { }; template struct rank<_Tp[]> : public integral_constant::value> { }; template struct extent : public integral_constant { }; template struct extent<_Tp[_Size], _Uint> : public integral_constant::value> { }; template struct extent<_Tp[], _Uint> : public integral_constant::value> { }; template struct is_same : public integral_constant { }; # 1410 "/usr/include/c++/10/type_traits" 3 template struct is_base_of : public integral_constant { }; template, is_function<_To>, is_array<_To>>::value> struct __is_convertible_helper { typedef typename is_void<_To>::type type; }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" template class __is_convertible_helper<_From, _To, false> { template static void __test_aux(_To1) noexcept; template(std::declval<_From1>()))> static true_type __test(int); template static false_type __test(...); public: typedef decltype(__test<_From, _To>(0)) type; }; #pragma GCC diagnostic pop template struct is_convertible : public __is_convertible_helper<_From, _To>::type { }; template using __is_array_convertible = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; template, is_function<_To>, is_array<_To>>::value> struct __is_nt_convertible_helper : is_void<_To> { }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" template class __is_nt_convertible_helper<_From, _To, false> { template static void __test_aux(_To1) noexcept; template static __bool_constant(std::declval<_From1>()))> __test(int); template static false_type __test(...); public: using type = decltype(__test<_From, _To>(0)); }; #pragma GCC diagnostic pop template struct __is_nothrow_convertible : public __is_nt_convertible_helper<_From, _To>::type { }; template struct is_nothrow_convertible : public __is_nt_convertible_helper<_From, _To>::type { }; template inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_From, _To>::value; template struct remove_const { typedef _Tp type; }; template struct remove_const<_Tp const> { typedef _Tp type; }; template struct remove_volatile { typedef _Tp type; }; template struct remove_volatile<_Tp volatile> { typedef _Tp type; }; template struct remove_cv { using type = _Tp; }; template struct remove_cv { using type = _Tp; }; template struct remove_cv { using type = _Tp; }; template struct remove_cv { using type = _Tp; }; template struct add_const { typedef _Tp const type; }; template struct add_volatile { typedef _Tp volatile type; }; template struct add_cv { typedef typename add_const::type>::type type; }; template using remove_const_t = typename remove_const<_Tp>::type; template using remove_volatile_t = typename remove_volatile<_Tp>::type; template using remove_cv_t = typename remove_cv<_Tp>::type; template using add_const_t = typename add_const<_Tp>::type; template using add_volatile_t = typename add_volatile<_Tp>::type; template using add_cv_t = typename add_cv<_Tp>::type; template struct remove_reference { typedef _Tp type; }; template struct remove_reference<_Tp&> { typedef _Tp type; }; template struct remove_reference<_Tp&&> { typedef _Tp type; }; template::value> struct __add_lvalue_reference_helper { typedef _Tp type; }; template struct __add_lvalue_reference_helper<_Tp, true> { typedef _Tp& type; }; template struct add_lvalue_reference : public __add_lvalue_reference_helper<_Tp> { }; template::value> struct __add_rvalue_reference_helper { typedef _Tp type; }; template struct __add_rvalue_reference_helper<_Tp, true> { typedef _Tp&& type; }; template struct add_rvalue_reference : public __add_rvalue_reference_helper<_Tp> { }; template using remove_reference_t = typename remove_reference<_Tp>::type; template using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; template using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; template struct __cv_selector; template struct __cv_selector<_Unqualified, false, false> { typedef _Unqualified __type; }; template struct __cv_selector<_Unqualified, false, true> { typedef volatile _Unqualified __type; }; template struct __cv_selector<_Unqualified, true, false> { typedef const _Unqualified __type; }; template struct __cv_selector<_Unqualified, true, true> { typedef const volatile _Unqualified __type; }; template::value, bool _IsVol = is_volatile<_Qualified>::value> class __match_cv_qualifiers { typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; public: typedef typename __match::__type __type; }; template struct __make_unsigned { typedef _Tp __type; }; template<> struct __make_unsigned { typedef unsigned char __type; }; template<> struct __make_unsigned { typedef unsigned char __type; }; template<> struct __make_unsigned { typedef unsigned short __type; }; template<> struct __make_unsigned { typedef unsigned int __type; }; template<> struct __make_unsigned { typedef unsigned long __type; }; template<> struct __make_unsigned { typedef unsigned long long __type; }; # 1730 "/usr/include/c++/10/type_traits" 3 template::value, bool _IsEnum = is_enum<_Tp>::value> class __make_unsigned_selector; template class __make_unsigned_selector<_Tp, true, false> { using __unsigned_type = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; public: using __type = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; }; class __make_unsigned_selector_base { protected: template struct _List { }; template struct _List<_Tp, _Up...> : _List<_Up...> { static constexpr size_t __size = sizeof(_Tp); }; template struct __select; template struct __select<_Sz, _List<_Uint, _UInts...>, true> { using __type = _Uint; }; template struct __select<_Sz, _List<_Uint, _UInts...>, false> : __select<_Sz, _List<_UInts...>> { }; }; template class __make_unsigned_selector<_Tp, false, true> : __make_unsigned_selector_base { using _UInts = _List; using __unsigned_type = typename __select::__type; public: using __type = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; }; template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template<> struct __make_unsigned { using __type = typename __make_unsigned_selector::__type; }; template struct make_unsigned { typedef typename __make_unsigned_selector<_Tp>::__type type; }; template<> struct make_unsigned; template struct __make_signed { typedef _Tp __type; }; template<> struct __make_signed { typedef signed char __type; }; template<> struct __make_signed { typedef signed char __type; }; template<> struct __make_signed { typedef signed short __type; }; template<> struct __make_signed { typedef signed int __type; }; template<> struct __make_signed { typedef signed long __type; }; template<> struct __make_signed { typedef signed long long __type; }; # 1884 "/usr/include/c++/10/type_traits" 3 template::value, bool _IsEnum = is_enum<_Tp>::value> class __make_signed_selector; template class __make_signed_selector<_Tp, true, false> { using __signed_type = typename __make_signed<__remove_cv_t<_Tp>>::__type; public: using __type = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; }; template class __make_signed_selector<_Tp, false, true> { typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; public: typedef typename __make_signed_selector<__unsigned_type>::__type __type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; template<> struct __make_signed { using __type = typename __make_signed_selector::__type; }; template struct make_signed { typedef typename __make_signed_selector<_Tp>::__type type; }; template<> struct make_signed; template using make_signed_t = typename make_signed<_Tp>::type; template using make_unsigned_t = typename make_unsigned<_Tp>::type; template struct remove_extent { typedef _Tp type; }; template struct remove_extent<_Tp[_Size]> { typedef _Tp type; }; template struct remove_extent<_Tp[]> { typedef _Tp type; }; template struct remove_all_extents { typedef _Tp type; }; template struct remove_all_extents<_Tp[_Size]> { typedef typename remove_all_extents<_Tp>::type type; }; template struct remove_all_extents<_Tp[]> { typedef typename remove_all_extents<_Tp>::type type; }; template using remove_extent_t = typename remove_extent<_Tp>::type; template using remove_all_extents_t = typename remove_all_extents<_Tp>::type; template struct __remove_pointer_helper { typedef _Tp type; }; template struct __remove_pointer_helper<_Tp, _Up*> { typedef _Up type; }; template struct remove_pointer : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> { }; template, is_void<_Tp>>::value> struct __add_pointer_helper { typedef _Tp type; }; template struct __add_pointer_helper<_Tp, true> { typedef typename remove_reference<_Tp>::type* type; }; template struct add_pointer : public __add_pointer_helper<_Tp> { }; template using remove_pointer_t = typename remove_pointer<_Tp>::type; template using add_pointer_t = typename add_pointer<_Tp>::type; template struct __aligned_storage_msa { union __type { unsigned char __data[_Len]; struct __attribute__((__aligned__)) { } __align; }; }; # 2067 "/usr/include/c++/10/type_traits" 3 template::__type)> struct aligned_storage { union type { unsigned char __data[_Len]; struct __attribute__((__aligned__((_Align)))) { } __align; }; }; template struct __strictest_alignment { static const size_t _S_alignment = 0; static const size_t _S_size = 0; }; template struct __strictest_alignment<_Tp, _Types...> { static const size_t _S_alignment = alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; static const size_t _S_size = sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; }; # 2106 "/usr/include/c++/10/type_traits" 3 template struct aligned_union { private: static_assert(sizeof...(_Types) != 0, "At least one type is required"); using __strictest = __strictest_alignment<_Types...>; static const size_t _S_len = _Len > __strictest::_S_size ? _Len : __strictest::_S_size; public: static const size_t alignment_value = __strictest::_S_alignment; typedef typename aligned_storage<_S_len, alignment_value>::type type; }; template const size_t aligned_union<_Len, _Types...>::alignment_value; template::value, bool _IsFunction = is_function<_Up>::value> struct __decay_selector; template struct __decay_selector<_Up, false, false> { typedef __remove_cv_t<_Up> __type; }; template struct __decay_selector<_Up, true, false> { typedef typename remove_extent<_Up>::type* __type; }; template struct __decay_selector<_Up, false, true> { typedef typename add_pointer<_Up>::type __type; }; template class decay { typedef typename remove_reference<_Tp>::type __remove_type; public: typedef typename __decay_selector<__remove_type>::__type type; }; template using __decay_t = typename decay<_Tp>::type; template class reference_wrapper; template struct __strip_reference_wrapper { typedef _Tp __type; }; template struct __strip_reference_wrapper > { typedef _Tp& __type; }; template using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; template struct enable_if { }; template struct enable_if { typedef _Tp type; }; template using __enable_if_t = typename enable_if<_Cond, _Tp>::type; template using _Require = __enable_if_t<__and_<_Cond...>::value>; template struct conditional { typedef _Iftrue type; }; template struct conditional { typedef _Iffalse type; }; template using __remove_cvref_t = typename remove_cv::type>::type; template struct common_type; struct __do_common_type_impl { template using __cond_t = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); template static __success_type<__decay_t<__cond_t<_Tp, _Up>>> _S_test(int); template static __success_type<__remove_cvref_t<__cond_t>> _S_test_2(int); template static __failure_type _S_test_2(...); template static decltype(_S_test_2<_Tp, _Up>(0)) _S_test(...); }; template<> struct common_type<> { }; template struct common_type<_Tp0> : public common_type<_Tp0, _Tp0> { }; template, typename _Dp2 = __decay_t<_Tp2>> struct __common_type_impl { using type = common_type<_Dp1, _Dp2>; }; template struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> : private __do_common_type_impl { using type = decltype(_S_test<_Tp1, _Tp2>(0)); }; template struct common_type<_Tp1, _Tp2> : public __common_type_impl<_Tp1, _Tp2>::type { }; template struct __common_type_pack { }; template struct __common_type_fold; template struct common_type<_Tp1, _Tp2, _Rp...> : public __common_type_fold, __common_type_pack<_Rp...>> { }; template struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, __void_t> : public common_type { }; template struct __common_type_fold<_CTp, _Rp, void> { }; template::value> struct __underlying_type_impl { using type = __underlying_type(_Tp); }; template struct __underlying_type_impl<_Tp, false> { }; template struct underlying_type : public __underlying_type_impl<_Tp> { }; template struct __declval_protector { static const bool __stop = false; }; template auto declval() noexcept -> decltype(__declval<_Tp>(0)) { static_assert(__declval_protector<_Tp>::__stop, "declval() must not be used!"); return __declval<_Tp>(0); } template class result_of; struct __invoke_memfun_ref { }; struct __invoke_memfun_deref { }; struct __invoke_memobj_ref { }; struct __invoke_memobj_deref { }; struct __invoke_other { }; template struct __result_of_success : __success_type<_Tp> { using __invoke_type = _Tag; }; struct __result_of_memfun_ref_impl { template static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) ), __invoke_memfun_ref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memfun_ref : private __result_of_memfun_ref_impl { typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; }; struct __result_of_memfun_deref_impl { template static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) ), __invoke_memfun_deref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memfun_deref : private __result_of_memfun_deref_impl { typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; }; struct __result_of_memobj_ref_impl { template static __result_of_success().*std::declval<_Fp>() ), __invoke_memobj_ref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memobj_ref : private __result_of_memobj_ref_impl { typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; }; struct __result_of_memobj_deref_impl { template static __result_of_success()).*std::declval<_Fp>() ), __invoke_memobj_deref> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_memobj_deref : private __result_of_memobj_deref_impl { typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; }; template struct __result_of_memobj; template struct __result_of_memobj<_Res _Class::*, _Arg> { typedef __remove_cvref_t<_Arg> _Argval; typedef _Res _Class::* _MemPtr; typedef typename conditional<__or_, is_base_of<_Class, _Argval>>::value, __result_of_memobj_ref<_MemPtr, _Arg>, __result_of_memobj_deref<_MemPtr, _Arg> >::type::type type; }; template struct __result_of_memfun; template struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> { typedef typename remove_reference<_Arg>::type _Argval; typedef _Res _Class::* _MemPtr; typedef typename conditional::value, __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, __result_of_memfun_deref<_MemPtr, _Arg, _Args...> >::type::type type; }; template> struct __inv_unwrap { using type = _Tp; }; template struct __inv_unwrap<_Tp, reference_wrapper<_Up>> { using type = _Up&; }; template struct __result_of_impl { typedef __failure_type type; }; template struct __result_of_impl : public __result_of_memobj<__decay_t<_MemPtr>, typename __inv_unwrap<_Arg>::type> { }; template struct __result_of_impl : public __result_of_memfun<__decay_t<_MemPtr>, typename __inv_unwrap<_Arg>::type, _Args...> { }; struct __result_of_other_impl { template static __result_of_success()(std::declval<_Args>()...) ), __invoke_other> _S_test(int); template static __failure_type _S_test(...); }; template struct __result_of_impl : private __result_of_other_impl { typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; }; template struct __invoke_result : public __result_of_impl< is_member_object_pointer< typename remove_reference<_Functor>::type >::value, is_member_function_pointer< typename remove_reference<_Functor>::type >::value, _Functor, _ArgTypes... >::type { }; template struct result_of<_Functor(_ArgTypes...)> : public __invoke_result<_Functor, _ArgTypes...> { }; template::__type)> using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; template using aligned_union_t = typename aligned_union<_Len, _Types...>::type; template using decay_t = typename decay<_Tp>::type; template using enable_if_t = typename enable_if<_Cond, _Tp>::type; template using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; template using common_type_t = typename common_type<_Tp...>::type; template using underlying_type_t = typename underlying_type<_Tp>::type; template using result_of_t = typename result_of<_Tp>::type; template using void_t = void; template class _Op, typename... _Args> struct __detector { using value_t = false_type; using type = _Default; }; template class _Op, typename... _Args> struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> { using value_t = true_type; using type = _Op<_Args...>; }; template class _Op, typename... _Args> using __detected_or = __detector<_Default, void, _Op, _Args...>; template class _Op, typename... _Args> using __detected_or_t = typename __detected_or<_Default, _Op, _Args...>::type; # 2624 "/usr/include/c++/10/type_traits" 3 template struct __is_swappable; template struct __is_nothrow_swappable; template class tuple; template struct __is_tuple_like_impl : false_type { }; template struct __is_tuple_like_impl> : true_type { }; template struct __is_tuple_like : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type { }; template constexpr inline _Require<__not_<__is_tuple_like<_Tp>>, is_move_constructible<_Tp>, is_move_assignable<_Tp>> swap(_Tp&, _Tp&) noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value); template 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(), std::declval<_Tp&>()))> static true_type __test(int); template static false_type __test(...); }; struct __do_is_nothrow_swappable_impl { template static __bool_constant< noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) > __test(int); template static false_type __test(...); }; } template struct __is_swappable_impl : public __swappable_details::__do_is_swappable_impl { typedef decltype(__test<_Tp>(0)) type; }; template struct __is_nothrow_swappable_impl : public __swappable_details::__do_is_nothrow_swappable_impl { typedef decltype(__test<_Tp>(0)) type; }; template struct __is_swappable : public __is_swappable_impl<_Tp>::type { }; template struct __is_nothrow_swappable : public __is_nothrow_swappable_impl<_Tp>::type { }; template struct is_swappable : public __is_swappable_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template struct is_nothrow_swappable : public __is_nothrow_swappable_impl<_Tp>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template inline constexpr bool is_swappable_v = is_swappable<_Tp>::value; template inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value; namespace __swappable_with_details { using std::swap; struct __do_is_swappable_with_impl { template(), std::declval<_Up>())), typename = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> static true_type __test(int); template static false_type __test(...); }; struct __do_is_nothrow_swappable_with_impl { template static __bool_constant< noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) && noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) > __test(int); template static false_type __test(...); }; } template struct __is_swappable_with_impl : public __swappable_with_details::__do_is_swappable_with_impl { typedef decltype(__test<_Tp, _Up>(0)) type; }; template struct __is_swappable_with_impl<_Tp&, _Tp&> : public __swappable_details::__do_is_swappable_impl { typedef decltype(__test<_Tp&>(0)) type; }; template struct __is_nothrow_swappable_with_impl : public __swappable_with_details::__do_is_nothrow_swappable_with_impl { typedef decltype(__test<_Tp, _Up>(0)) type; }; template struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> : public __swappable_details::__do_is_nothrow_swappable_impl { typedef decltype(__test<_Tp&>(0)) type; }; template struct is_swappable_with : public __is_swappable_with_impl<_Tp, _Up>::type { }; template struct is_nothrow_swappable_with : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type { }; template inline constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value; template inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value; template::value, typename = void> struct __is_invocable_impl : false_type { }; template struct __is_invocable_impl<_Result, _Ret, true, __void_t> : true_type { }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" template struct __is_invocable_impl<_Result, _Ret, false, __void_t> { private: static typename _Result::type _S_get(); template static void _S_conv(_Tp); template(_S_get()))> static true_type _S_test(int); template static false_type _S_test(...); public: using type = decltype(_S_test<_Ret>(1)); }; #pragma GCC diagnostic pop template struct __is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type { }; template constexpr bool __call_is_nt(__invoke_memfun_ref) { using _Up = typename __inv_unwrap<_Tp>::type; return noexcept((std::declval<_Up>().*std::declval<_Fn>())( std::declval<_Args>()...)); } template constexpr bool __call_is_nt(__invoke_memfun_deref) { return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( std::declval<_Args>()...)); } template constexpr bool __call_is_nt(__invoke_memobj_ref) { using _Up = typename __inv_unwrap<_Tp>::type; return noexcept(std::declval<_Up>().*std::declval<_Fn>()); } template constexpr bool __call_is_nt(__invoke_memobj_deref) { return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); } template constexpr bool __call_is_nt(__invoke_other) { return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); } template struct __call_is_nothrow : __bool_constant< std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) > { }; template using __call_is_nothrow_ = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; template struct __is_nothrow_invocable : __and_<__is_invocable<_Fn, _Args...>, __call_is_nothrow_<_Fn, _Args...>>::type { }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" struct __nonesuchbase {}; struct __nonesuch : private __nonesuchbase { ~__nonesuch() = delete; __nonesuch(__nonesuch const&) = delete; void operator=(__nonesuch const&) = delete; }; #pragma GCC diagnostic pop template struct invoke_result : public __invoke_result<_Functor, _ArgTypes...> { }; template using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; template struct is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), "_Fn must be a complete class or an unbounded array"); }; template struct is_invocable_r : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), "_Fn must be a complete class or an unbounded array"); }; template struct is_nothrow_invocable : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, __call_is_nothrow_<_Fn, _ArgTypes...>>::type { static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), "_Fn must be a complete class or an unbounded array"); }; template struct __is_nt_invocable_impl : false_type { }; template struct __is_nt_invocable_impl<_Result, _Ret, __void_t> : __or_, __is_nothrow_convertible> { }; template struct is_nothrow_invocable_r : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, __call_is_nothrow_<_Fn, _ArgTypes...>>::type { }; template inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; template inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value; template inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value; template inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; template inline constexpr bool is_void_v = is_void<_Tp>::value; template inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; template inline constexpr bool is_integral_v = is_integral<_Tp>::value; template inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; template inline constexpr bool is_array_v = is_array<_Tp>::value; template inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; template inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value; template inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value; template inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value; template inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value; template inline constexpr bool is_enum_v = is_enum<_Tp>::value; template inline constexpr bool is_union_v = is_union<_Tp>::value; template inline constexpr bool is_class_v = is_class<_Tp>::value; template inline constexpr bool is_function_v = is_function<_Tp>::value; template inline constexpr bool is_reference_v = is_reference<_Tp>::value; template inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; template inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; template inline constexpr bool is_object_v = is_object<_Tp>::value; template inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; template inline constexpr bool is_compound_v = is_compound<_Tp>::value; template inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; template inline constexpr bool is_const_v = is_const<_Tp>::value; template inline constexpr bool is_volatile_v = is_volatile<_Tp>::value; template inline constexpr bool is_trivial_v = is_trivial<_Tp>::value; template inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<_Tp>::value; template inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template [[deprecated("use is_standard_layout_v && is_trivial_v instead")]] inline constexpr bool is_pod_v = is_pod<_Tp>::value; #pragma GCC diagnostic pop template inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value; template inline constexpr bool is_empty_v = is_empty<_Tp>::value; template inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value; template inline constexpr bool is_abstract_v = is_abstract<_Tp>::value; template inline constexpr bool is_final_v = is_final<_Tp>::value; template inline constexpr bool is_signed_v = is_signed<_Tp>::value; template inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; template inline constexpr bool is_constructible_v = is_constructible<_Tp, _Args...>::value; template inline constexpr bool is_default_constructible_v = is_default_constructible<_Tp>::value; template inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value; template inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value; template inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value; template inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value; template inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value; template inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; template inline constexpr bool is_trivially_constructible_v = is_trivially_constructible<_Tp, _Args...>::value; template inline constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<_Tp>::value; template inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value; template inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value; template inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<_Tp, _Up>::value; template inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value; template inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value; template inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value; template inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value; template inline constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<_Tp>::value; template inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value; template inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value; template inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<_Tp, _Up>::value; template inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value; template inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value; template inline constexpr bool is_nothrow_destructible_v = is_nothrow_destructible<_Tp>::value; template inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<_Tp>::value; template inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; template inline constexpr size_t rank_v = rank<_Tp>::value; template inline constexpr size_t extent_v = extent<_Tp, _Idx>::value; template inline constexpr bool is_same_v = __is_same_as(_Tp, _Up); template inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value; template inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; template struct has_unique_object_representations : bool_constant<__has_unique_object_representations( remove_cv_t> )> { static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), "template argument must be a complete class or an unbounded array"); }; template inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value; template struct is_aggregate : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { }; template inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value; template struct remove_cvref { using type = __remove_cvref_t<_Tp>; }; template using remove_cvref_t = __remove_cvref_t<_Tp>; template struct type_identity { using type = _Tp; }; template using type_identity_t = typename type_identity<_Tp>::type; template struct unwrap_reference { using type = _Tp; }; template struct unwrap_reference> { using type = _Tp&; }; template using unwrap_reference_t = typename unwrap_reference<_Tp>::type; template struct unwrap_ref_decay { using type = unwrap_reference_t>; }; template using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type; template struct is_bounded_array : public __is_array_known_bounds<_Tp> { }; template struct is_unbounded_array : public __is_array_unknown_bounds<_Tp> { }; template inline constexpr bool is_bounded_array_v = is_bounded_array<_Tp>::value; template inline constexpr bool is_unbounded_array_v = is_unbounded_array<_Tp>::value; constexpr inline bool is_constant_evaluated() noexcept { return __builtin_is_constant_evaluated(); } template using __copy_cv = typename __match_cv_qualifiers<_From, _To>::__type; template using __cond_res = decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()()); template struct __common_ref_impl { }; template using __common_ref = typename __common_ref_impl<_Ap, _Bp>::type; template struct __common_ref_impl<_Xp&, _Yp&, __void_t<__cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>>> { using type = __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>; }; template using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&; template struct __common_ref_impl<_Xp&&, _Yp&&, _Require>, is_convertible<_Yp&&, __common_ref_C<_Xp, _Yp>>>> { using type = __common_ref_C<_Xp, _Yp>; }; template using __common_ref_D = __common_ref; template struct __common_ref_impl<_Xp&&, _Yp&, _Require>>> { using type = __common_ref_D<_Xp, _Yp>; }; template struct __common_ref_impl<_Xp&, _Yp&&> : __common_ref_impl<_Yp&&, _Xp&> { }; template class _TQual, template class _UQual> struct basic_common_reference { }; template struct __xref { template using __type = __copy_cv<_Tp, _Up>; }; template struct __xref<_Tp&> { template using __type = __copy_cv<_Tp, _Up>&; }; template struct __xref<_Tp&&> { template using __type = __copy_cv<_Tp, _Up>&&; }; template using __basic_common_ref = typename basic_common_reference, remove_cvref_t<_Tp2>, __xref<_Tp1>::template __type, __xref<_Tp2>::template __type>::type; template struct common_reference; template using common_reference_t = typename common_reference<_Tp...>::type; template<> struct common_reference<> { }; template struct common_reference<_Tp0> { using type = _Tp0; }; template struct __common_reference_impl : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1> { }; template struct common_reference<_Tp1, _Tp2> : __common_reference_impl<_Tp1, _Tp2> { }; template struct __common_reference_impl<_Tp1&, _Tp2&, 1, void_t<__common_ref<_Tp1&, _Tp2&>>> { using type = __common_ref<_Tp1&, _Tp2&>; }; template struct __common_reference_impl<_Tp1&&, _Tp2&&, 1, void_t<__common_ref<_Tp1&&, _Tp2&&>>> { using type = __common_ref<_Tp1&&, _Tp2&&>; }; template struct __common_reference_impl<_Tp1&, _Tp2&&, 1, void_t<__common_ref<_Tp1&, _Tp2&&>>> { using type = __common_ref<_Tp1&, _Tp2&&>; }; template struct __common_reference_impl<_Tp1&&, _Tp2&, 1, void_t<__common_ref<_Tp1&&, _Tp2&>>> { using type = __common_ref<_Tp1&&, _Tp2&>; }; template struct __common_reference_impl<_Tp1, _Tp2, 2, void_t<__basic_common_ref<_Tp1, _Tp2>>> { using type = __basic_common_ref<_Tp1, _Tp2>; }; template struct __common_reference_impl<_Tp1, _Tp2, 3, void_t<__cond_res<_Tp1, _Tp2>>> { using type = __cond_res<_Tp1, _Tp2>; }; template struct __common_reference_impl<_Tp1, _Tp2, 4, void_t>> { using type = common_type_t<_Tp1, _Tp2>; }; template struct __common_reference_impl<_Tp1, _Tp2, 5, void> { }; template struct common_reference<_Tp1, _Tp2, _Rest...> : __common_type_fold, __common_type_pack<_Rest...>> { }; template struct __common_type_fold, __common_type_pack<_Rest...>, void_t>> : public common_reference, _Rest...> { }; } # 45 "/usr/include/c++/10/concepts" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template concept __same_as = std::is_same_v<_Tp, _Up>; } template concept same_as = __detail::__same_as<_Tp, _Up> && __detail::__same_as<_Up, _Tp>; template concept derived_from = __is_base_of(_Base, _Derived) && is_convertible_v; template concept convertible_to = is_convertible_v<_From, _To> && requires(add_rvalue_reference_t<_From> (&__f)()) { static_cast<_To>(__f()); }; template concept common_reference_with = same_as, common_reference_t<_Up, _Tp>> && convertible_to<_Tp, common_reference_t<_Tp, _Up>> && convertible_to<_Up, common_reference_t<_Tp, _Up>>; template concept common_with = same_as, common_type_t<_Up, _Tp>> && requires { static_cast>(std::declval<_Tp>()); static_cast>(std::declval<_Up>()); } && common_reference_with, add_lvalue_reference_t> && common_reference_with>, common_reference_t< add_lvalue_reference_t, add_lvalue_reference_t>>; template concept integral = is_integral_v<_Tp>; template concept signed_integral = integral<_Tp> && is_signed_v<_Tp>; template concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>; template concept floating_point = is_floating_point_v<_Tp>; namespace __detail { template using __cref = const remove_reference_t<_Tp>&; template concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>; } template 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 concept destructible = is_nothrow_destructible_v<_Tp>; template concept constructible_from = destructible<_Tp> && is_constructible_v<_Tp, _Args...>; template concept default_initializable = constructible_from<_Tp> && requires { _Tp{}; (void) ::new _Tp; }; template concept move_constructible = constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>; template concept copy_constructible = move_constructible<_Tp> && constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> && constructible_from<_Tp, const _Tp&> && convertible_to && constructible_from<_Tp, const _Tp> && convertible_to; namespace ranges { namespace __cust_swap { template void swap(_Tp&, _Tp&) = delete; template concept __adl_swap = (__detail::__class_or_enum> || __detail::__class_or_enum>) && requires(_Tp&& __t, _Up&& __u) { swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }; struct _Swap { private: template 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> && is_nothrow_move_assignable_v>; } public: template requires __adl_swap<_Tp, _Up> || (same_as<_Tp, _Up> && is_lvalue_reference_v<_Tp> && move_constructible> && 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&&>(__t); __t = static_cast&&>(__u); __u = static_cast&&>(__tmp); } } template 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()(*__e1, *__e2))) { for (size_t __n = 0; __n < _Num; ++__n) (*this)(__e1[__n], __e2[__n]); } }; } inline namespace __cust { inline constexpr __cust_swap::_Swap swap{}; } } template concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); }; template 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 concept movable = is_object_v<_Tp> && move_constructible<_Tp> && assignable_from<_Tp&, _Tp> && swappable<_Tp>; template concept copyable = copy_constructible<_Tp> && movable<_Tp> && assignable_from<_Tp&, _Tp&> && assignable_from<_Tp&, const _Tp&> && assignable_from<_Tp&, const _Tp>; template concept semiregular = copyable<_Tp> && default_initializable<_Tp>; namespace __detail { template concept __boolean_testable_impl = convertible_to<_Tp, bool>; template concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) { { !static_cast<_Tp&&>(__t) } -> __boolean_testable_impl; }; } namespace __detail { template 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 concept equality_comparable = __detail::__weakly_eq_cmp_with<_Tp, _Tp>; template concept equality_comparable_with = equality_comparable<_Tp> && equality_comparable<_Up> && common_reference_with<__detail::__cref<_Tp>, __detail::__cref<_Up>> && equality_comparable, __detail::__cref<_Up>>> && __detail::__weakly_eq_cmp_with<_Tp, _Up>; namespace __detail { template 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 concept totally_ordered = equality_comparable<_Tp> && __detail::__partially_ordered_with<_Tp, _Tp>; template concept totally_ordered_with = totally_ordered<_Tp> && totally_ordered<_Up> && equality_comparable_with<_Tp, _Up> && totally_ordered, __detail::__cref<_Up>>> && __detail::__partially_ordered_with<_Tp, _Up>; template concept regular = semiregular<_Tp> && equality_comparable<_Tp>; template concept invocable = is_invocable_v<_Fn, _Args...>; template concept regular_invocable = invocable<_Fn, _Args...>; template concept predicate = regular_invocable<_Fn, _Args...> && __detail::__boolean_testable>; template concept relation = predicate<_Rel, _Tp, _Tp> && predicate<_Rel, _Up, _Up> && predicate<_Rel, _Tp, _Up> && predicate<_Rel, _Up, _Tp>; template concept equivalence_relation = relation<_Rel, _Tp, _Up>; template concept strict_weak_order = relation<_Rel, _Tp, _Up>; } # 10 "all-std.cxx" 2 # 1 "/usr/include/c++/10/any" 1 3 # 32 "/usr/include/c++/10/any" 3 # 33 "/usr/include/c++/10/any" 3 # 1 "/usr/include/c++/10/typeinfo" 1 3 # 32 "/usr/include/c++/10/typeinfo" 3 # 33 "/usr/include/c++/10/typeinfo" 3 # 1 "/usr/include/c++/10/bits/exception.h" 1 3 # 34 "/usr/include/c++/10/bits/exception.h" 3 # 35 "/usr/include/c++/10/bits/exception.h" 3 #pragma GCC visibility push(default) extern "C++" { namespace std { # 60 "/usr/include/c++/10/bits/exception.h" 3 class exception { public: exception() noexcept { } virtual ~exception() noexcept; exception(const exception&) = default; exception& operator=(const exception&) = default; exception(exception&&) = default; exception& operator=(exception&&) = default; virtual const char* what() const noexcept; }; } } #pragma GCC visibility pop # 35 "/usr/include/c++/10/typeinfo" 2 3 # 1 "/usr/include/c++/10/bits/hash_bytes.h" 1 3 # 33 "/usr/include/c++/10/bits/hash_bytes.h" 3 # 34 "/usr/include/c++/10/bits/hash_bytes.h" 3 namespace std { size_t _Hash_bytes(const void* __ptr, size_t __len, size_t __seed); size_t _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed); } # 37 "/usr/include/c++/10/typeinfo" 2 3 #pragma GCC visibility push(default) extern "C++" { namespace __cxxabiv1 { class __class_type_info; } # 80 "/usr/include/c++/10/typeinfo" 3 namespace std { class type_info { public: virtual ~type_info(); const char* name() const noexcept { return __name[0] == '*' ? __name + 1 : __name; } # 115 "/usr/include/c++/10/typeinfo" 3 bool before(const type_info& __arg) const noexcept { return (__name[0] == '*' && __arg.__name[0] == '*') ? __name < __arg.__name : __builtin_strcmp (__name, __arg.__name) < 0; } bool operator==(const type_info& __arg) const noexcept { return ((__name == __arg.__name) || (__name[0] != '*' && __builtin_strcmp (__name, __arg.__name) == 0)); } # 143 "/usr/include/c++/10/typeinfo" 3 size_t hash_code() const noexcept { return _Hash_bytes(name(), __builtin_strlen(name()), static_cast(0xc70f6907UL)); } virtual bool __is_pointer_p() const; virtual bool __is_function_p() const; virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj, unsigned __outer) const; virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target, void **__obj_ptr) const; protected: const char *__name; explicit type_info(const char *__n): __name(__n) { } private: type_info& operator=(const type_info&); type_info(const type_info&); }; class bad_cast : public exception { public: bad_cast() noexcept { } virtual ~bad_cast() noexcept; virtual const char* what() const noexcept; }; class bad_typeid : public exception { public: bad_typeid () noexcept { } virtual ~bad_typeid() noexcept; virtual const char* what() const noexcept; }; } } #pragma GCC visibility pop # 37 "/usr/include/c++/10/any" 2 3 # 1 "/usr/include/c++/10/new" 1 3 # 38 "/usr/include/c++/10/new" 3 # 39 "/usr/include/c++/10/new" 3 # 1 "/usr/include/c++/10/exception" 1 3 # 33 "/usr/include/c++/10/exception" 3 # 34 "/usr/include/c++/10/exception" 3 #pragma GCC visibility push(default) extern "C++" { namespace std { class bad_exception : public exception { public: bad_exception() noexcept { } virtual ~bad_exception() noexcept; virtual const char* what() const noexcept; }; typedef void (*terminate_handler) (); typedef void (*unexpected_handler) (); terminate_handler set_terminate(terminate_handler) noexcept; terminate_handler get_terminate() noexcept; void terminate() noexcept __attribute__ ((__noreturn__)); unexpected_handler set_unexpected(unexpected_handler) noexcept; unexpected_handler get_unexpected() noexcept; void unexpected() __attribute__ ((__noreturn__)); # 105 "/usr/include/c++/10/exception" 3 [[__deprecated__]] bool uncaught_exception() noexcept __attribute__ ((__pure__)); int uncaught_exceptions() noexcept __attribute__ ((__pure__)); } namespace __gnu_cxx { # 137 "/usr/include/c++/10/exception" 3 void __verbose_terminate_handler(); } } #pragma GCC visibility pop # 1 "/usr/include/c++/10/bits/exception_ptr.h" 1 3 # 34 "/usr/include/c++/10/bits/exception_ptr.h" 3 #pragma GCC visibility push(default) # 1 "/usr/include/c++/10/bits/exception_defines.h" 1 3 # 38 "/usr/include/c++/10/bits/exception_ptr.h" 2 3 # 1 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 1 3 # 34 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3 # 35 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 3 #pragma GCC visibility push(default) # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 143 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4 typedef long int ptrdiff_t; # 209 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4 typedef long unsigned int size_t; # 415 "/usr/lib/gcc/x86_64-linux-gnu/10/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)))); # 426 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 3 4 } max_align_t; typedef decltype(nullptr) nullptr_t; # 39 "/usr/include/c++/10/bits/cxxabi_init_exception.h" 2 3 # 50 "/usr/include/c++/10/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 # 39 "/usr/include/c++/10/bits/exception_ptr.h" 2 3 # 1 "/usr/include/c++/10/new" 1 3 # 41 "/usr/include/c++/10/bits/exception_ptr.h" 2 3 extern "C++" { namespace std { class type_info; namespace __exception_ptr { class exception_ptr; } using __exception_ptr::exception_ptr; exception_ptr current_exception() noexcept; template exception_ptr make_exception_ptr(_Ex) noexcept; void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); namespace __exception_ptr { using std::rethrow_exception; class exception_ptr { void* _M_exception_object; explicit exception_ptr(void* __e) noexcept; void _M_addref() noexcept; void _M_release() noexcept; void *_M_get() const noexcept __attribute__ ((__pure__)); friend exception_ptr std::current_exception() noexcept; friend void std::rethrow_exception(exception_ptr); template friend exception_ptr std::make_exception_ptr(_Ex) noexcept; public: exception_ptr() noexcept; exception_ptr(const exception_ptr&) noexcept; exception_ptr(nullptr_t) noexcept : _M_exception_object(0) { } exception_ptr(exception_ptr&& __o) noexcept : _M_exception_object(__o._M_exception_object) { __o._M_exception_object = 0; } # 118 "/usr/include/c++/10/bits/exception_ptr.h" 3 exception_ptr& operator=(const exception_ptr&) noexcept; exception_ptr& operator=(exception_ptr&& __o) noexcept { exception_ptr(static_cast(__o)).swap(*this); return *this; } ~exception_ptr() noexcept; void swap(exception_ptr&) noexcept; # 145 "/usr/include/c++/10/bits/exception_ptr.h" 3 explicit operator bool() const { return _M_exception_object; } friend bool operator==(const exception_ptr&, const exception_ptr&) noexcept __attribute__ ((__pure__)); const class std::type_info* __cxa_exception_type() const noexcept __attribute__ ((__pure__)); }; bool operator==(const exception_ptr&, const exception_ptr&) noexcept __attribute__ ((__pure__)); bool operator!=(const exception_ptr&, const exception_ptr&) noexcept __attribute__ ((__pure__)); inline void swap(exception_ptr& __lhs, exception_ptr& __rhs) { __lhs.swap(__rhs); } template inline void __dest_thunk(void* __x) { static_cast<_Ex*>(__x)->~_Ex(); } } template exception_ptr make_exception_ptr(_Ex __ex) noexcept { void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); (void) __cxxabiv1::__cxa_init_primary_exception( __e, const_cast(&typeid(__ex)), __exception_ptr::__dest_thunk<_Ex>); try { ::new (__e) _Ex(__ex); return exception_ptr(__e); } catch(...) { __cxxabiv1::__cxa_free_exception(__e); return current_exception(); } # 215 "/usr/include/c++/10/bits/exception_ptr.h" 3 } } } #pragma GCC visibility pop # 148 "/usr/include/c++/10/exception" 2 3 # 1 "/usr/include/c++/10/bits/nested_exception.h" 1 3 # 33 "/usr/include/c++/10/bits/nested_exception.h" 3 #pragma GCC visibility push(default) # 1 "/usr/include/c++/10/bits/move.h" 1 3 # 38 "/usr/include/c++/10/bits/move.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template inline constexpr _Tp* __addressof(_Tp& __r) noexcept { return __builtin_addressof(__r); } } namespace std __attribute__ ((__visibility__ ("default"))) { # 74 "/usr/include/c++/10/bits/move.h" 3 template constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept { return static_cast<_Tp&&>(__t); } template constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcept { static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument" " substituting _Tp is an lvalue reference type"); return static_cast<_Tp&&>(__t); } template constexpr typename std::remove_reference<_Tp>::type&& move(_Tp&& __t) noexcept { return static_cast::type&&>(__t); } template struct __move_if_noexcept_cond : public __and_<__not_>, is_copy_constructible<_Tp>>::type { }; # 118 "/usr/include/c++/10/bits/move.h" 3 template constexpr typename conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type move_if_noexcept(_Tp& __x) noexcept { return std::move(__x); } # 138 "/usr/include/c++/10/bits/move.h" 3 template inline constexpr _Tp* addressof(_Tp& __r) noexcept { return std::__addressof(__r); } template const _Tp* addressof(const _Tp&&) = delete; template constexpr inline _Tp __exchange(_Tp& __obj, _Up&& __new_val) { _Tp __old_val = std::move(__obj); __obj = std::forward<_Up>(__new_val); return __old_val; } # 179 "/usr/include/c++/10/bits/move.h" 3 template 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_assignable<_Tp>>::value) { _Tp __tmp = std::move(__a); __a = std::move(__b); __b = std::move(__tmp); } template 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]); } } # 41 "/usr/include/c++/10/bits/nested_exception.h" 2 3 extern "C++" { namespace std { class nested_exception { exception_ptr _M_ptr; public: nested_exception() noexcept : _M_ptr(current_exception()) { } nested_exception(const nested_exception&) noexcept = default; nested_exception& operator=(const nested_exception&) noexcept = default; virtual ~nested_exception() noexcept; [[noreturn]] void rethrow_nested() const { if (_M_ptr) rethrow_exception(_M_ptr); std::terminate(); } exception_ptr nested_ptr() const noexcept { return _M_ptr; } }; template struct _Nested_exception : public _Except, public nested_exception { explicit _Nested_exception(const _Except& __ex) : _Except(__ex) { } explicit _Nested_exception(_Except&& __ex) : _Except(static_cast<_Except&&>(__ex)) { } }; template [[noreturn]] inline void __throw_with_nested_impl(_Tp&& __t, true_type) { using _Up = typename remove_reference<_Tp>::type; throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; } template [[noreturn]] inline void __throw_with_nested_impl(_Tp&& __t, false_type) { throw std::forward<_Tp>(__t); } template [[noreturn]] inline void throw_with_nested(_Tp&& __t) { using _Up = typename decay<_Tp>::type; using _CopyConstructible = __and_, is_move_constructible<_Up>>; static_assert(_CopyConstructible::value, "throw_with_nested argument must be CopyConstructible"); using __nest = __and_, __bool_constant, __not_>>; std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{}); } template using __rethrow_if_nested_cond = typename enable_if< __and_, __or_<__not_>, is_convertible<_Tp*, nested_exception*>>>::value >::type; template inline __rethrow_if_nested_cond<_Ex> __rethrow_if_nested_impl(const _Ex* __ptr) { if (auto __ne_ptr = dynamic_cast(__ptr)) __ne_ptr->rethrow_nested(); } inline void __rethrow_if_nested_impl(const void*) { } template inline void rethrow_if_nested(const _Ex& __ex) { std::__rethrow_if_nested_impl(std::__addressof(__ex)); } } } #pragma GCC visibility pop # 149 "/usr/include/c++/10/exception" 2 3 # 42 "/usr/include/c++/10/new" 2 3 #pragma GCC visibility push(default) extern "C++" { namespace std { class bad_alloc : public exception { public: bad_alloc() throw() { } bad_alloc(const bad_alloc&) = default; bad_alloc& operator=(const bad_alloc&) = default; virtual ~bad_alloc() throw(); virtual const char* what() const throw(); }; class bad_array_new_length : public bad_alloc { public: bad_array_new_length() throw() { } virtual ~bad_array_new_length() throw(); virtual const char* what() const throw(); }; enum class align_val_t: size_t {}; struct nothrow_t { explicit nothrow_t() = default; }; extern const nothrow_t nothrow; typedef void (*new_handler)(); new_handler set_new_handler(new_handler) throw(); new_handler get_new_handler() noexcept; } # 126 "/usr/include/c++/10/new" 3 [[__nodiscard__]] void* operator new(std::size_t) __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new[](std::size_t) __attribute__((__externally_visible__)); void operator delete(void*) noexcept __attribute__((__externally_visible__)); void operator delete[](void*) noexcept __attribute__((__externally_visible__)); void operator delete(void*, std::size_t) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, std::size_t) noexcept __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __malloc__)); [[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __malloc__)); void operator delete(void*, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __malloc__)); void operator delete(void*, std::align_val_t) noexcept __attribute__((__externally_visible__)); void operator delete(void*, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) __attribute__((__externally_visible__)); [[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__, __malloc__)); void operator delete[](void*, std::align_val_t) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, std::align_val_t, const std::nothrow_t&) noexcept __attribute__((__externally_visible__)); void operator delete(void*, std::size_t, std::align_val_t) noexcept __attribute__((__externally_visible__)); void operator delete[](void*, std::size_t, std::align_val_t) noexcept __attribute__((__externally_visible__)); [[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept { return __p; } [[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept { return __p; } inline void operator delete (void*, void*) noexcept { } inline void operator delete[](void*, void*) noexcept { } } namespace std { template [[nodiscard]] constexpr _Tp* launder(_Tp* __p) noexcept { return __builtin_launder(__p); } template void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; template void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; void launder(void*) = delete; void launder(const void*) = delete; void launder(volatile void*) = delete; void launder(const volatile void*) = delete; } namespace std { struct destroying_delete_t { explicit destroying_delete_t() = default; }; inline constexpr destroying_delete_t destroying_delete{}; } #pragma GCC visibility pop # 38 "/usr/include/c++/10/any" 2 3 # 1 "/usr/include/c++/10/utility" 1 3 # 58 "/usr/include/c++/10/utility" 3 # 59 "/usr/include/c++/10/utility" 3 # 69 "/usr/include/c++/10/utility" 3 # 1 "/usr/include/c++/10/bits/stl_relops.h" 1 3 # 67 "/usr/include/c++/10/bits/stl_relops.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace rel_ops { # 85 "/usr/include/c++/10/bits/stl_relops.h" 3 template inline bool operator!=(const _Tp& __x, const _Tp& __y) { return !(__x == __y); } # 98 "/usr/include/c++/10/bits/stl_relops.h" 3 template inline bool operator>(const _Tp& __x, const _Tp& __y) { return __y < __x; } # 111 "/usr/include/c++/10/bits/stl_relops.h" 3 template inline bool operator<=(const _Tp& __x, const _Tp& __y) { return !(__y < __x); } # 124 "/usr/include/c++/10/bits/stl_relops.h" 3 template inline bool operator>=(const _Tp& __x, const _Tp& __y) { return !(__x < __y); } } } # 70 "/usr/include/c++/10/utility" 2 3 # 1 "/usr/include/c++/10/bits/stl_pair.h" 1 3 # 65 "/usr/include/c++/10/bits/stl_pair.h" 3 # 1 "/usr/include/c++/10/compare" 1 3 # 33 "/usr/include/c++/10/compare" 3 # 34 "/usr/include/c++/10/compare" 3 #pragma GCC visibility push(default) 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 { constexpr __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; friend constexpr bool operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value == 0; } friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default; friend constexpr bool operator< (partial_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value == -1; } friend constexpr bool operator> (partial_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value == 1; } friend constexpr bool operator<=(partial_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value <= 0; } friend constexpr bool operator>=(partial_ordering __v, __cmp_cat::__unspec) noexcept { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; } friend constexpr bool operator< (__cmp_cat::__unspec, partial_ordering __v) noexcept { return __v._M_value == 1; } friend constexpr bool operator> (__cmp_cat::__unspec, partial_ordering __v) noexcept { return __v._M_value == -1; } friend constexpr bool operator<=(__cmp_cat::__unspec, partial_ordering __v) noexcept { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; } friend constexpr bool operator>=(__cmp_cat::__unspec, partial_ordering __v) noexcept { return 0 >= __v._M_value; } friend constexpr partial_ordering operator<=>(partial_ordering __v, __cmp_cat::__unspec) noexcept { return __v; } 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; constexpr operator partial_ordering() const noexcept { return partial_ordering(__cmp_cat::_Ord(_M_value)); } friend constexpr bool operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value == 0; } friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default; friend constexpr bool operator< (weak_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value < 0; } friend constexpr bool operator> (weak_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value > 0; } friend constexpr bool operator<=(weak_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value <= 0; } friend constexpr bool operator>=(weak_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value >= 0; } friend constexpr bool operator< (__cmp_cat::__unspec, weak_ordering __v) noexcept { return 0 < __v._M_value; } friend constexpr bool operator> (__cmp_cat::__unspec, weak_ordering __v) noexcept { return 0 > __v._M_value; } friend constexpr bool operator<=(__cmp_cat::__unspec, weak_ordering __v) noexcept { return 0 <= __v._M_value; } friend constexpr bool operator>=(__cmp_cat::__unspec, weak_ordering __v) noexcept { return 0 >= __v._M_value; } friend constexpr weak_ordering operator<=>(weak_ordering __v, __cmp_cat::__unspec) noexcept { return __v; } 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; constexpr operator partial_ordering() const noexcept { return partial_ordering(__cmp_cat::_Ord(_M_value)); } constexpr operator weak_ordering() const noexcept { return weak_ordering(__cmp_cat::_Ord(_M_value)); } friend constexpr bool operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value == 0; } friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default; friend constexpr bool operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value < 0; } friend constexpr bool operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value > 0; } friend constexpr bool operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value <= 0; } friend constexpr bool operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept { return __v._M_value >= 0; } friend constexpr bool operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept { return 0 < __v._M_value; } friend constexpr bool operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept { return 0 > __v._M_value; } friend constexpr bool operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept { return 0 <= __v._M_value; } friend constexpr bool operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept { return 0 >= __v._M_value; } friend constexpr strong_ordering operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept { return __v; } 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); constexpr bool is_eq(partial_ordering __cmp) noexcept { return __cmp == 0; } constexpr bool is_neq(partial_ordering __cmp) noexcept { return __cmp != 0; } constexpr bool is_lt (partial_ordering __cmp) noexcept { return __cmp < 0; } constexpr bool is_lteq(partial_ordering __cmp) noexcept { return __cmp <= 0; } constexpr bool is_gt (partial_ordering __cmp) noexcept { return __cmp > 0; } constexpr bool is_gteq(partial_ordering __cmp) noexcept { return __cmp >= 0; } namespace __detail { template inline constexpr unsigned __cmp_cat_id = 1; template<> inline constexpr unsigned __cmp_cat_id = 2; template<> inline constexpr unsigned __cmp_cat_id = 4; template<> inline constexpr unsigned __cmp_cat_id = 8; template 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)) return partial_ordering::equivalent; else if constexpr (bool(__cats & __cmp_cat_id)) return weak_ordering::equivalent; else return strong_ordering::equivalent; } } template struct common_comparison_category { using type = decltype(__detail::__common_cmp_cat<_Ts...>()); }; template struct common_comparison_category<_Tp> { using type = void; }; template<> struct common_comparison_category { using type = partial_ordering; }; template<> struct common_comparison_category { using type = weak_ordering; }; template<> struct common_comparison_category { using type = strong_ordering; }; template<> struct common_comparison_category<> { using type = strong_ordering; }; template using common_comparison_category_t = typename common_comparison_category<_Ts...>::type; namespace __detail { template concept __compares_as = same_as, _Cat>; } template 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 concept three_way_comparable_with = three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> && common_reference_with&, const remove_reference_t<_Up>&> && three_way_comparable< common_reference_t&, 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 using __cmp3way_res_t = decltype(std::declval<_Tp>() <=> std::declval<_Up>()); template struct __cmp3way_res_impl { }; template 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 struct compare_three_way_result : __detail::__cmp3way_res_impl<_Tp, _Up> { }; template using compare_three_way_result_t = typename __detail::__cmp3way_res_impl<_Tp, _Up>::type; namespace __detail { template 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 requires three_way_comparable_with<_Tp, _Up> constexpr auto operator()(_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(__t); auto __pu = static_cast(__u); if (__builtin_is_constant_evaluated()) return __pt <=> __pu; auto __it = reinterpret_cast(__pt); auto __iu = reinterpret_cast(__pu); return __it <=> __iu; } else return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); } using is_transparent = void; }; namespace __cmp_cust { template 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; } } template concept __adl_strong = requires(_Tp&& __t, _Up&& __u) { strong_ordering(strong_order(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u))); }; template concept __adl_weak = requires(_Tp&& __t, _Up&& __u) { weak_ordering(weak_order(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u))); }; template concept __adl_partial = requires(_Tp&& __t, _Up&& __u) { partial_ordering(partial_order(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u))); }; template concept __cmp3way = requires(_Tp&& __t, _Up&& __u, compare_three_way __c) { _Ord(__c(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u))); }; template concept __strongly_ordered = __adl_strong<_Tp, _Up> || __cmp3way; class _Strong_order { template static constexpr bool _S_noexcept() { if constexpr (floating_point>) 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) return noexcept(compare_three_way()(std::declval<_Tp>(), std::declval<_Up>())); } friend class _Weak_order; friend class _Strong_fallback; public: template requires __strongly_ordered<_Tp, _Up> constexpr strong_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { static_assert(same_as, decay_t<_Up>>); if constexpr (__adl_strong<_Tp, _Up>) return strong_ordering(strong_order(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f))); else if constexpr (__cmp3way) return compare_three_way()(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f)); } }; template concept __weakly_ordered = floating_point> || __adl_weak<_Tp, _Up> || __cmp3way || __strongly_ordered<_Tp, _Up>; class _Weak_order { template static constexpr bool _S_noexcept() { if constexpr (floating_point>) 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) 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 requires __weakly_ordered<_Tp, _Up> constexpr weak_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { static_assert(same_as, decay_t<_Up>>); if constexpr (floating_point>) return __cmp_cust::__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) 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 concept __partially_ordered = __adl_partial<_Tp, _Up> || __cmp3way || __weakly_ordered<_Tp, _Up>; class _Partial_order { template 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) 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 requires __partially_ordered<_Tp, _Up> constexpr partial_ordering operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { static_assert(same_as, decay_t<_Up>>); if constexpr (__adl_partial<_Tp, _Up>) return partial_ordering(partial_order(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f))); else if constexpr (__cmp3way) 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 concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u) { { static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) } -> convertible_to; { static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) } -> convertible_to; }; class _Strong_fallback { template 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 requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> constexpr decltype(auto) operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { static_assert(same_as, decay_t<_Up>>); if constexpr (__strongly_ordered<_Tp, _Up>) return _Strong_order{}(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f)); else if constexpr (__op_eq_lt<_Tp, _Up>) 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 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 requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> constexpr decltype(auto) operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { static_assert(same_as, decay_t<_Up>>); if constexpr (__weakly_ordered<_Tp, _Up>) return _Weak_order{}(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f)); else if constexpr (__op_eq_lt<_Tp, _Up>) 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; } }; class _Partial_fallback { template 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 requires __partially_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up> constexpr decltype(auto) operator()(_Tp&& __e, _Up&& __f) const noexcept(_S_noexcept<_Tp, _Up>()) { static_assert(same_as, decay_t<_Up>>); if constexpr (__partially_ordered<_Tp, _Up>) return _Partial_order{}(static_cast<_Tp&&>(__e), static_cast<_Up&&>(__f)); else if constexpr (__op_eq_lt<_Tp, _Up>) 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 __cmp_alg { inline constexpr __cmp_cust::_Strong_order strong_order{}; inline constexpr __cmp_cust::_Weak_order weak_order{}; inline constexpr __cmp_cust::_Partial_order partial_order{}; inline constexpr __cmp_cust::_Strong_fallback compare_strong_order_fallback{}; inline constexpr __cmp_cust::_Weak_fallback compare_weak_order_fallback{}; inline constexpr __cmp_cust::_Partial_fallback compare_partial_order_fallback{}; } namespace __detail { inline constexpr struct _Synth3way { template 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 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 using __synth3way_t = decltype(__detail::__synth3way(std::declval<_Tp&>(), std::declval<_Up&>())); } } #pragma GCC visibility pop # 66 "/usr/include/c++/10/bits/stl_pair.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 80 "/usr/include/c++/10/bits/stl_pair.h" 3 struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); template class tuple; template struct _Index_tuple; template struct _PCC { template static constexpr bool _ConstructiblePair() { return __and_, is_constructible<_T2, const _U2&>>::value; } template static constexpr bool _ImplicitlyConvertiblePair() { return __and_, is_convertible>::value; } template static constexpr bool _MoveConstructiblePair() { return __and_, is_constructible<_T2, _U2&&>>::value; } template static constexpr bool _ImplicitlyMoveConvertiblePair() { return __and_, is_convertible<_U2&&, _T2>>::value; } template static constexpr bool _CopyMovePair() { using __do_converts = __and_, is_convertible<_U2&&, _T2>>; using __converts = typename conditional<__implicit, __do_converts, __not_<__do_converts>>::type; return __and_, is_constructible<_T2, _U2&&>, __converts >::value; } template static constexpr bool _MoveCopyPair() { using __do_converts = __and_, is_convertible>; using __converts = typename conditional<__implicit, __do_converts, __not_<__do_converts>>::type; return __and_, is_constructible<_T2, const _U2&&>, __converts >::value; } }; template struct _PCC { template static constexpr bool _ConstructiblePair() { return false; } template static constexpr bool _ImplicitlyConvertiblePair() { return false; } template static constexpr bool _MoveConstructiblePair() { return false; } template static constexpr bool _ImplicitlyMoveConvertiblePair() { return false; } }; template class __pair_base { template friend struct pair; __pair_base() = default; ~__pair_base() = default; __pair_base(const __pair_base&) = default; __pair_base& operator=(const __pair_base&) = delete; }; # 210 "/usr/include/c++/10/bits/stl_pair.h" 3 template struct pair : private __pair_base<_T1, _T2> { typedef _T1 first_type; typedef _T2 second_type; _T1 first; _T2 second; template , __is_implicitly_default_constructible<_U2>> ::value, bool>::type = true> constexpr pair() : first(), second() { } template , is_default_constructible<_U2>, __not_< __and_<__is_implicitly_default_constructible<_U1>, __is_implicitly_default_constructible<_U2>>>> ::value, bool>::type = false> explicit constexpr pair() : first(), second() { } # 256 "/usr/include/c++/10/bits/stl_pair.h" 3 using _PCCP = _PCC; template() && _PCCP::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) { } template() && !_PCCP::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) { } # 288 "/usr/include/c++/10/bits/stl_pair.h" 3 template using _PCCFP = _PCC::value || !is_same<_T2, _U2>::value, _T1, _T2>; template::template _ConstructiblePair<_U1, _U2>() && _PCCFP<_U1, _U2>::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) { } template::template _ConstructiblePair<_U1, _U2>() && !_PCCFP<_U1, _U2>::template _ImplicitlyConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) { } constexpr pair(const pair&) = default; constexpr pair(pair&&) = default; template(), bool>::type=true> constexpr pair(_U1&& __x, const _T2& __y) : first(std::forward<_U1>(__x)), second(__y) { } template(), bool>::type=false> explicit constexpr pair(_U1&& __x, const _T2& __y) : first(std::forward<_U1>(__x)), second(__y) { } template(), bool>::type=true> constexpr pair(const _T1& __x, _U2&& __y) : first(__x), second(std::forward<_U2>(__y)) { } template(), bool>::type=false> explicit pair(const _T1& __x, _U2&& __y) : first(__x), second(std::forward<_U2>(__y)) { } template() && _PCCP::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(_U1&& __x, _U2&& __y) : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } template() && !_PCCP::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(_U1&& __x, _U2&& __y) : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } template::template _MoveConstructiblePair<_U1, _U2>() && _PCCFP<_U1, _U2>::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=true> constexpr pair(pair<_U1, _U2>&& __p) : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) { } template::template _MoveConstructiblePair<_U1, _U2>() && !_PCCFP<_U1, _U2>::template _ImplicitlyMoveConvertiblePair<_U1, _U2>(), bool>::type=false> explicit constexpr pair(pair<_U1, _U2>&& __p) : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) { } template constexpr pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); constexpr pair& operator=(typename conditional< __and_, is_copy_assignable<_T2>>::value, const pair&, const __nonesuch&>::type __p) { first = __p.first; second = __p.second; return *this; } constexpr pair& operator=(typename conditional< __and_, is_move_assignable<_T2>>::value, pair&&, __nonesuch&&>::type __p) noexcept(__and_, is_nothrow_move_assignable<_T2>>::value) { first = std::forward(__p.first); second = std::forward(__p.second); return *this; } template constexpr typename enable_if<__and_, is_assignable<_T2&, const _U2&>>::value, pair&>::type operator=(const pair<_U1, _U2>& __p) { first = __p.first; second = __p.second; return *this; } template constexpr typename enable_if<__and_, is_assignable<_T2&, _U2&&>>::value, pair&>::type operator=(pair<_U1, _U2>&& __p) { first = std::forward<_U1>(__p.first); second = std::forward<_U2>(__p.second); return *this; } 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); } private: template constexpr pair(tuple<_Args1...>&, tuple<_Args2...>&, _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); }; template pair(_T1, _T2) -> pair<_T1, _T2>; template inline constexpr bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __x.first == __y.first && __x.second == __y.second; } template constexpr common_comparison_category_t<__detail::__synth3way_t<_T1>, __detail::__synth3way_t<_T2>> operator<=>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { if (auto __c = __detail::__synth3way(__x.first, __y.first); __c != 0) return __c; return __detail::__synth3way(__x.second, __y.second); } # 524 "/usr/include/c++/10/bits/stl_pair.h" 3 template 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 enable_if, __is_swappable<_T2>>::value>::type swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; # 564 "/usr/include/c++/10/bits/stl_pair.h" 3 template constexpr pair::__type, typename __decay_and_strip<_T2>::__type> make_pair(_T1&& __x, _T2&& __y) { typedef typename __decay_and_strip<_T1>::__type __ds_type1; typedef typename __decay_and_strip<_T2>::__type __ds_type2; typedef pair<__ds_type1, __ds_type2> __pair_type; return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); } # 583 "/usr/include/c++/10/bits/stl_pair.h" 3 } # 71 "/usr/include/c++/10/utility" 2 3 # 1 "/usr/include/c++/10/initializer_list" 1 3 # 33 "/usr/include/c++/10/initializer_list" 3 # 34 "/usr/include/c++/10/initializer_list" 3 #pragma GCC visibility push(default) namespace std { template class initializer_list { public: typedef _E value_type; typedef const _E& reference; typedef const _E& const_reference; typedef size_t size_type; typedef const _E* iterator; typedef const _E* const_iterator; private: iterator _M_array; size_type _M_len; constexpr initializer_list(const_iterator __a, size_type __l) : _M_array(__a), _M_len(__l) { } public: constexpr initializer_list() noexcept : _M_array(0), _M_len(0) { } constexpr size_type size() const noexcept { return _M_len; } constexpr const_iterator begin() const noexcept { return _M_array; } constexpr const_iterator end() const noexcept { return begin() + size(); } }; template constexpr const _Tp* begin(initializer_list<_Tp> __ils) noexcept { return __ils.begin(); } template constexpr const _Tp* end(initializer_list<_Tp> __ils) noexcept { return __ils.end(); } } #pragma GCC visibility pop # 77 "/usr/include/c++/10/utility" 2 3 # 1 "/usr/include/c++/10/ext/numeric_traits.h" 1 3 # 32 "/usr/include/c++/10/ext/numeric_traits.h" 3 # 33 "/usr/include/c++/10/ext/numeric_traits.h" 3 # 1 "/usr/include/c++/10/bits/cpp_type_traits.h" 1 3 # 35 "/usr/include/c++/10/bits/cpp_type_traits.h" 3 # 36 "/usr/include/c++/10/bits/cpp_type_traits.h" 3 # 67 "/usr/include/c++/10/bits/cpp_type_traits.h" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { struct __true_type { }; struct __false_type { }; template struct __truth_type { typedef __false_type __type; }; template<> struct __truth_type { typedef __true_type __type; }; template struct __traitor { enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; typedef typename __truth_type<__value>::__type __type; }; template struct __are_same { enum { __value = 0 }; typedef __false_type __type; }; template struct __are_same<_Tp, _Tp> { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_void { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_void { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_integer { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; # 287 "/usr/include/c++/10/bits/cpp_type_traits.h" 3 template struct __is_floating { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_pointer { enum { __value = 0 }; typedef __false_type __type; }; template struct __is_pointer<_Tp*> { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_arithmetic : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > { }; template struct __is_scalar : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > { }; template struct __is_char { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_char { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_char { enum { __value = 1 }; typedef __true_type __type; }; template struct __is_byte { enum { __value = 0 }; typedef __false_type __type; }; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; enum class byte : unsigned char; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; }; template struct iterator_traits; template struct __is_nonvolatile_trivially_copyable { enum { __value = __is_trivially_copyable(_Tp) }; }; template struct __is_nonvolatile_trivially_copyable { enum { __value = 0 }; }; template struct __memcpyable { enum { __value = 0 }; }; template struct __memcpyable<_Tp*, _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcpyable<_Tp*, const _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcmpable { enum { __value = 0 }; }; template struct __memcmpable<_Tp*, _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcmpable : __is_nonvolatile_trivially_copyable<_Tp> { }; template struct __memcmpable<_Tp*, const _Tp*> : __is_nonvolatile_trivially_copyable<_Tp> { }; template::__value> struct __is_memcmp_ordered { static const bool __value = _Tp(-1) > _Tp(1); }; template struct __is_memcmp_ordered<_Tp, false> { static const bool __value = false; }; template struct __is_memcmp_ordered_with { static const bool __value = __is_memcmp_ordered<_Tp>::__value && __is_memcmp_ordered<_Up>::__value; }; template struct __is_memcmp_ordered_with<_Tp, _Up, false> { static const bool __value = false; }; template<> struct __is_memcmp_ordered_with { static constexpr bool __value = true; }; template struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> { static constexpr bool __value = false; }; template struct __is_memcmp_ordered_with { static constexpr bool __value = false; }; template struct __is_move_iterator { enum { __value = 0 }; typedef __false_type __type; }; template constexpr inline _Iterator __miter_base(_Iterator __it) { return __it; } } } # 35 "/usr/include/c++/10/ext/numeric_traits.h" 2 3 # 1 "/usr/include/c++/10/ext/type_traits.h" 1 3 # 32 "/usr/include/c++/10/ext/type_traits.h" 3 # 33 "/usr/include/c++/10/ext/type_traits.h" 3 extern "C++" { namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { template struct __enable_if { }; template struct __enable_if { typedef _Tp __type; }; template struct __conditional_type { typedef _Iftrue __type; }; template struct __conditional_type { typedef _Iffalse __type; }; template struct __add_unsigned { private: typedef __enable_if::__value, _Tp> __if_type; public: typedef typename __if_type::__type __type; }; template<> struct __add_unsigned { typedef unsigned char __type; }; template<> struct __add_unsigned { typedef unsigned char __type; }; template<> struct __add_unsigned { typedef unsigned short __type; }; template<> struct __add_unsigned { typedef unsigned int __type; }; template<> struct __add_unsigned { typedef unsigned long __type; }; template<> struct __add_unsigned { typedef unsigned long long __type; }; template<> struct __add_unsigned; template<> struct __add_unsigned; template struct __remove_unsigned { private: typedef __enable_if::__value, _Tp> __if_type; public: typedef typename __if_type::__type __type; }; template<> struct __remove_unsigned { typedef signed char __type; }; template<> struct __remove_unsigned { typedef signed char __type; }; template<> struct __remove_unsigned { typedef short __type; }; template<> struct __remove_unsigned { typedef int __type; }; template<> struct __remove_unsigned { typedef long __type; }; template<> struct __remove_unsigned { typedef long long __type; }; template<> struct __remove_unsigned; template<> struct __remove_unsigned; template inline bool __is_null_pointer(_Type* __ptr) { return __ptr == 0; } template inline bool __is_null_pointer(_Type) { return false; } inline bool __is_null_pointer(std::nullptr_t) { return true; } template::__value> struct __promote { typedef double __type; }; template struct __promote<_Tp, false> { }; template<> struct __promote { typedef long double __type; }; template<> struct __promote { typedef double __type; }; template<> struct __promote { typedef float __type; }; template::__type, typename _Up2 = typename __promote<_Up>::__type> struct __promote_2 { typedef __typeof__(_Tp2() + _Up2()) __type; }; template::__type, typename _Up2 = typename __promote<_Up>::__type, typename _Vp2 = typename __promote<_Vp>::__type> struct __promote_3 { typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type; }; template::__type, typename _Up2 = typename __promote<_Up>::__type, typename _Vp2 = typename __promote<_Vp>::__type, typename _Wp2 = typename __promote<_Wp>::__type> struct __promote_4 { typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type; }; } } # 36 "/usr/include/c++/10/ext/numeric_traits.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 50 "/usr/include/c++/10/ext/numeric_traits.h" 3 template struct __is_integer_nonstrict : public std::__is_integer<_Tp> { using std::__is_integer<_Tp>::__value; enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; }; template struct __numeric_traits_integer { static_assert(__is_integer_nonstrict<_Value>::__value, "invalid specialization"); static const bool __is_signed = (_Value)(-1) < 0; static const int __digits = __is_integer_nonstrict<_Value>::__width - __is_signed; static const _Value __max = __is_signed ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) : ~(_Value)0; static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; }; template const _Value __numeric_traits_integer<_Value>::__min; template const _Value __numeric_traits_integer<_Value>::__max; template const bool __numeric_traits_integer<_Value>::__is_signed; template const int __numeric_traits_integer<_Value>::__digits; # 128 "/usr/include/c++/10/ext/numeric_traits.h" 3 template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; template using __int_traits = __numeric_traits_integer<_Tp>; # 155 "/usr/include/c++/10/ext/numeric_traits.h" 3 template struct __numeric_traits_floating { static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 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 const int __numeric_traits_floating<_Value>::__max_digits10; template const bool __numeric_traits_floating<_Value>::__is_signed; template const int __numeric_traits_floating<_Value>::__digits10; template const int __numeric_traits_floating<_Value>::__max_exponent10; template struct __numeric_traits : public __conditional_type<__is_integer_nonstrict<_Value>::__value, __numeric_traits_integer<_Value>, __numeric_traits_floating<_Value> >::__type { }; } # 80 "/usr/include/c++/10/utility" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct tuple_size; template::type, typename = typename enable_if::value>::type, size_t = tuple_size<_Tp>::value> using __enable_if_has_tuple_size = _Tp; template struct tuple_size> : public tuple_size<_Tp> { }; template struct tuple_size> : public tuple_size<_Tp> { }; template struct tuple_size> : public tuple_size<_Tp> { }; template struct tuple_element; template using __tuple_element_t = typename tuple_element<__i, _Tp>::type; template struct tuple_element<__i, const _Tp> { typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type; }; template struct tuple_element<__i, volatile _Tp> { typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type; }; template struct tuple_element<__i, const volatile _Tp> { typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type; }; template using tuple_element_t = typename tuple_element<__i, _Tp>::type; template struct __is_tuple_like_impl> : true_type { }; template struct tuple_size> : public integral_constant { }; template struct tuple_element<0, std::pair<_Tp1, _Tp2>> { typedef _Tp1 type; }; template struct tuple_element<1, std::pair<_Tp1, _Tp2>> { typedef _Tp2 type; }; template struct __pair_get; template<> struct __pair_get<0> { template static constexpr _Tp1& __get(std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.first; } template static constexpr _Tp1&& __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward<_Tp1>(__pair.first); } template static constexpr const _Tp1& __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.first; } template static constexpr const _Tp1&& __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward(__pair.first); } }; template<> struct __pair_get<1> { template static constexpr _Tp2& __get(std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.second; } template static constexpr _Tp2&& __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward<_Tp2>(__pair.second); } template static constexpr const _Tp2& __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept { return __pair.second; } template static constexpr const _Tp2&& __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept { return std::forward(__pair.second); } }; template constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& get(std::pair<_Tp1, _Tp2>& __in) noexcept { return __pair_get<_Int>::__get(__in); } template constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&& get(std::pair<_Tp1, _Tp2>&& __in) noexcept { return __pair_get<_Int>::__move_get(std::move(__in)); } template constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type& get(const std::pair<_Tp1, _Tp2>& __in) noexcept { return __pair_get<_Int>::__const_get(__in); } template constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&& get(const std::pair<_Tp1, _Tp2>&& __in) noexcept { return __pair_get<_Int>::__const_move_get(std::move(__in)); } template constexpr _Tp& get(pair<_Tp, _Up>& __p) noexcept { return __p.first; } template constexpr const _Tp& get(const pair<_Tp, _Up>& __p) noexcept { return __p.first; } template constexpr _Tp&& get(pair<_Tp, _Up>&& __p) noexcept { return std::move(__p.first); } template constexpr const _Tp&& get(const pair<_Tp, _Up>&& __p) noexcept { return std::move(__p.first); } template constexpr _Tp& get(pair<_Up, _Tp>& __p) noexcept { return __p.second; } template constexpr const _Tp& get(const pair<_Up, _Tp>& __p) noexcept { return __p.second; } template constexpr _Tp&& get(pair<_Up, _Tp>&& __p) noexcept { return std::move(__p.second); } template constexpr const _Tp&& get(const pair<_Up, _Tp>&& __p) noexcept { return std::move(__p.second); } template constexpr inline _Tp exchange(_Tp& __obj, _Up&& __new_val) { return std::__exchange(__obj, std::forward<_Up>(__new_val)); } template struct _Index_tuple { }; # 307 "/usr/include/c++/10/utility" 3 template struct _Build_index_tuple { using __type = _Index_tuple<__integer_pack(_Num)...>; }; template struct integer_sequence { typedef _Tp value_type; static constexpr size_t size() noexcept { return sizeof...(_Idx); } }; template using make_integer_sequence = integer_sequence<_Tp, __integer_pack(_Num)...>; template using index_sequence = integer_sequence; template using make_index_sequence = make_integer_sequence; template using index_sequence_for = make_index_sequence; struct in_place_t { explicit in_place_t() = default; }; inline constexpr in_place_t in_place{}; template struct in_place_type_t { explicit in_place_type_t() = default; }; template inline constexpr in_place_type_t<_Tp> in_place_type{}; template struct in_place_index_t { explicit in_place_index_t() = default; }; template inline constexpr in_place_index_t<_Idx> in_place_index{}; template struct __is_in_place_type_impl : false_type { }; template struct __is_in_place_type_impl> : true_type { }; template struct __is_in_place_type : public __is_in_place_type_impl<_Tp> { }; template constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; } template void as_const(const _Tp&&) = delete; template constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept { static_assert(__is_standard_integer<_Tp>::value); static_assert(__is_standard_integer<_Up>::value); if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>) return __t == __u; else if constexpr (is_signed_v<_Tp>) return __t >= 0 && make_unsigned_t<_Tp>(__t) == __u; else return __u >= 0 && __t == make_unsigned_t<_Up>(__u); } template constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept { return !std::cmp_equal(__t, __u); } template constexpr bool cmp_less(_Tp __t, _Up __u) noexcept { static_assert(__is_standard_integer<_Tp>::value); static_assert(__is_standard_integer<_Up>::value); if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>) return __t < __u; else if constexpr (is_signed_v<_Tp>) return __t < 0 || make_unsigned_t<_Tp>(__t) < __u; else return __u >= 0 && __t < make_unsigned_t<_Up>(__u); } template constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept { return std::cmp_less(__u, __t); } template constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept { return !std::cmp_less(__u, __t); } template constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept { return !std::cmp_less(__t, __u); } template constexpr bool in_range(_Tp __t) noexcept { static_assert(__is_standard_integer<_Up>::value); static_assert(__is_standard_integer<_Tp>::value); using __gnu_cxx::__int_traits; if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>) return __int_traits<_Up>::__min <= __t && __t <= __int_traits<_Up>::__max; else if constexpr (is_signed_v<_Tp>) return __t >= 0 && make_unsigned_t<_Tp>(__t) <= __int_traits<_Up>::__max; else return __t <= make_unsigned_t<_Up>(__int_traits<_Up>::__max); } } # 39 "/usr/include/c++/10/any" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 54 "/usr/include/c++/10/any" 3 class bad_any_cast : public bad_cast { public: virtual const char* what() const noexcept { return "bad any_cast"; } }; [[gnu::noreturn]] inline void __throw_bad_any_cast() { throw bad_any_cast{}; } # 77 "/usr/include/c++/10/any" 3 class any { union _Storage { constexpr _Storage() : _M_ptr{nullptr} {} _Storage(const _Storage&) = delete; _Storage& operator=(const _Storage&) = delete; void* _M_ptr; aligned_storage::type _M_buffer; }; template, bool _Fits = (sizeof(_Tp) <= sizeof(_Storage)) && (alignof(_Tp) <= alignof(_Storage))> using _Internal = std::integral_constant; template struct _Manager_internal; template struct _Manager_external; template using _Manager = conditional_t<_Internal<_Tp>::value, _Manager_internal<_Tp>, _Manager_external<_Tp>>; template> using _Decay_if_not_any = enable_if_t, _VTp>; template > void __do_emplace(_Args&&... __args) { reset(); _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...); _M_manager = &_Mgr::_S_manage; } template > void __do_emplace(initializer_list<_Up> __il, _Args&&... __args) { reset(); _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...); _M_manager = &_Mgr::_S_manage; } template using __any_constructible = enable_if<__and_, is_constructible<_Tp, _Args...>>::value, _Res>; template using __any_constructible_t = typename __any_constructible::type; template using __emplace_t = typename __any_constructible<_VTp&, _VTp, _Args...>::type; public: constexpr any() noexcept : _M_manager(nullptr) { } any(const any& __other) { if (!__other.has_value()) _M_manager = nullptr; else { _Arg __arg; __arg._M_any = this; __other._M_manager(_Op_clone, &__other, &__arg); } } any(any&& __other) noexcept { if (!__other.has_value()) _M_manager = nullptr; else { _Arg __arg; __arg._M_any = this; __other._M_manager(_Op_xfer, &__other, &__arg); } } template , typename _Mgr = _Manager<_VTp>, enable_if_t::value && !__is_in_place_type<_VTp>::value, bool> = true> any(_Tp&& __value) : _M_manager(&_Mgr::_S_manage) { _Mgr::_S_create(_M_storage, std::forward<_Tp>(__value)); } template , typename _Mgr = _Manager<_VTp>, __any_constructible_t<_VTp, _Args&&...> = false> explicit any(in_place_type_t<_Tp>, _Args&&... __args) : _M_manager(&_Mgr::_S_manage) { _Mgr::_S_create(_M_storage, std::forward<_Args>(__args)...); } template , typename _Mgr = _Manager<_VTp>, __any_constructible_t<_VTp, initializer_list<_Up>, _Args&&...> = false> explicit any(in_place_type_t<_Tp>, initializer_list<_Up> __il, _Args&&... __args) : _M_manager(&_Mgr::_S_manage) { _Mgr::_S_create(_M_storage, __il, std::forward<_Args>(__args)...); } ~any() { reset(); } any& operator=(const any& __rhs) { *this = any(__rhs); return *this; } any& operator=(any&& __rhs) noexcept { if (!__rhs.has_value()) reset(); else if (this != &__rhs) { reset(); _Arg __arg; __arg._M_any = this; __rhs._M_manager(_Op_xfer, &__rhs, &__arg); } return *this; } template enable_if_t>::value, any&> operator=(_Tp&& __rhs) { *this = any(std::forward<_Tp>(__rhs)); return *this; } template __emplace_t, _Args...> emplace(_Args&&... __args) { using _VTp = decay_t<_Tp>; __do_emplace<_VTp>(std::forward<_Args>(__args)...); any::_Arg __arg; this->_M_manager(any::_Op_access, this, &__arg); return *static_cast<_VTp*>(__arg._M_obj); } template __emplace_t, initializer_list<_Up>, _Args&&...> emplace(initializer_list<_Up> __il, _Args&&... __args) { using _VTp = decay_t<_Tp>; __do_emplace<_VTp, _Up>(__il, std::forward<_Args>(__args)...); any::_Arg __arg; this->_M_manager(any::_Op_access, this, &__arg); return *static_cast<_VTp*>(__arg._M_obj); } void reset() noexcept { if (has_value()) { _M_manager(_Op_destroy, this, nullptr); _M_manager = nullptr; } } void swap(any& __rhs) noexcept { if (!has_value() && !__rhs.has_value()) return; if (has_value() && __rhs.has_value()) { if (this == &__rhs) return; any __tmp; _Arg __arg; __arg._M_any = &__tmp; __rhs._M_manager(_Op_xfer, &__rhs, &__arg); __arg._M_any = &__rhs; _M_manager(_Op_xfer, this, &__arg); __arg._M_any = this; __tmp._M_manager(_Op_xfer, &__tmp, &__arg); } else { any* __empty = !has_value() ? this : &__rhs; any* __full = !has_value() ? &__rhs : this; _Arg __arg; __arg._M_any = __empty; __full->_M_manager(_Op_xfer, __full, &__arg); } } bool has_value() const noexcept { return _M_manager != nullptr; } const type_info& type() const noexcept { if (!has_value()) return typeid(void); _Arg __arg; _M_manager(_Op_get_type_info, this, &__arg); return *__arg._M_typeinfo; } template static constexpr bool __is_valid_cast() { return __or_, is_copy_constructible<_Tp>>::value; } private: enum _Op { _Op_access, _Op_get_type_info, _Op_clone, _Op_destroy, _Op_xfer }; union _Arg { void* _M_obj; const std::type_info* _M_typeinfo; any* _M_any; }; void (*_M_manager)(_Op, const any*, _Arg*); _Storage _M_storage; template friend void* __any_caster(const any* __any); template struct _Manager_internal { static void _S_manage(_Op __which, const any* __anyp, _Arg* __arg); template static void _S_create(_Storage& __storage, _Up&& __value) { void* __addr = &__storage._M_buffer; ::new (__addr) _Tp(std::forward<_Up>(__value)); } template static void _S_create(_Storage& __storage, _Args&&... __args) { void* __addr = &__storage._M_buffer; ::new (__addr) _Tp(std::forward<_Args>(__args)...); } }; template struct _Manager_external { static void _S_manage(_Op __which, const any* __anyp, _Arg* __arg); template static void _S_create(_Storage& __storage, _Up&& __value) { __storage._M_ptr = new _Tp(std::forward<_Up>(__value)); } template static void _S_create(_Storage& __storage, _Args&&... __args) { __storage._M_ptr = new _Tp(std::forward<_Args>(__args)...); } }; }; inline void swap(any& __x, any& __y) noexcept { __x.swap(__y); } template any make_any(_Args&&... __args) { return any(in_place_type<_Tp>, std::forward<_Args>(__args)...); } template any make_any(initializer_list<_Up> __il, _Args&&... __args) { return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...); } # 438 "/usr/include/c++/10/any" 3 template inline _ValueType any_cast(const any& __any) { using _Up = __remove_cvref_t<_ValueType>; static_assert(any::__is_valid_cast<_ValueType>(), "Template argument must be a reference or CopyConstructible type"); static_assert(is_constructible_v<_ValueType, const _Up&>, "Template argument must be constructible from a const value."); auto __p = any_cast<_Up>(&__any); if (__p) return static_cast<_ValueType>(*__p); __throw_bad_any_cast(); } # 464 "/usr/include/c++/10/any" 3 template inline _ValueType any_cast(any& __any) { using _Up = __remove_cvref_t<_ValueType>; static_assert(any::__is_valid_cast<_ValueType>(), "Template argument must be a reference or CopyConstructible type"); static_assert(is_constructible_v<_ValueType, _Up&>, "Template argument must be constructible from an lvalue."); auto __p = any_cast<_Up>(&__any); if (__p) return static_cast<_ValueType>(*__p); __throw_bad_any_cast(); } template inline _ValueType any_cast(any&& __any) { using _Up = __remove_cvref_t<_ValueType>; static_assert(any::__is_valid_cast<_ValueType>(), "Template argument must be a reference or CopyConstructible type"); static_assert(is_constructible_v<_ValueType, _Up>, "Template argument must be constructible from an rvalue."); auto __p = any_cast<_Up>(&__any); if (__p) return static_cast<_ValueType>(std::move(*__p)); __throw_bad_any_cast(); } template void* __any_caster(const any* __any) { using _Up = remove_cv_t<_Tp>; if constexpr (!is_same_v, _Up>) return nullptr; else if constexpr (!is_copy_constructible_v<_Up>) return nullptr; else if (__any->_M_manager == &any::_Manager<_Up>::_S_manage || __any->type() == typeid(_Tp) ) { any::_Arg __arg; __any->_M_manager(any::_Op_access, __any, &__arg); return __arg._M_obj; } return nullptr; } # 533 "/usr/include/c++/10/any" 3 template inline const _ValueType* any_cast(const any* __any) noexcept { if constexpr (is_object_v<_ValueType>) if (__any) return static_cast<_ValueType*>(__any_caster<_ValueType>(__any)); return nullptr; } template inline _ValueType* any_cast(any* __any) noexcept { if constexpr (is_object_v<_ValueType>) if (__any) return static_cast<_ValueType*>(__any_caster<_ValueType>(__any)); return nullptr; } template void any::_Manager_internal<_Tp>:: _S_manage(_Op __which, const any* __any, _Arg* __arg) { auto __ptr = reinterpret_cast(&__any->_M_storage._M_buffer); switch (__which) { case _Op_access: __arg->_M_obj = const_cast<_Tp*>(__ptr); break; case _Op_get_type_info: __arg->_M_typeinfo = &typeid(_Tp); break; case _Op_clone: ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp(*__ptr); __arg->_M_any->_M_manager = __any->_M_manager; break; case _Op_destroy: __ptr->~_Tp(); break; case _Op_xfer: ::new(&__arg->_M_any->_M_storage._M_buffer) _Tp (std::move(*const_cast<_Tp*>(__ptr))); __ptr->~_Tp(); __arg->_M_any->_M_manager = __any->_M_manager; const_cast(__any)->_M_manager = nullptr; break; } } template void any::_Manager_external<_Tp>:: _S_manage(_Op __which, const any* __any, _Arg* __arg) { auto __ptr = static_cast(__any->_M_storage._M_ptr); switch (__which) { case _Op_access: __arg->_M_obj = const_cast<_Tp*>(__ptr); break; case _Op_get_type_info: __arg->_M_typeinfo = &typeid(_Tp); break; case _Op_clone: __arg->_M_any->_M_storage._M_ptr = new _Tp(*__ptr); __arg->_M_any->_M_manager = __any->_M_manager; break; case _Op_destroy: delete __ptr; break; case _Op_xfer: __arg->_M_any->_M_storage._M_ptr = __any->_M_storage._M_ptr; __arg->_M_any->_M_manager = __any->_M_manager; const_cast(__any)->_M_manager = nullptr; break; } } namespace __detail::__variant { template struct _Never_valueless_alt; template<> struct _Never_valueless_alt : std::true_type { }; } } # 12 "all-std.cxx" 2 # 1 "/usr/include/c++/10/bitset" 1 3 # 45 "/usr/include/c++/10/bitset" 3 # 46 "/usr/include/c++/10/bitset" 3 # 1 "/usr/include/c++/10/string" 1 3 # 36 "/usr/include/c++/10/string" 3 # 37 "/usr/include/c++/10/string" 3 # 1 "/usr/include/c++/10/bits/stringfwd.h" 1 3 # 37 "/usr/include/c++/10/bits/stringfwd.h" 3 # 38 "/usr/include/c++/10/bits/stringfwd.h" 3 # 1 "/usr/include/c++/10/bits/memoryfwd.h" 1 3 # 46 "/usr/include/c++/10/bits/memoryfwd.h" 3 # 47 "/usr/include/c++/10/bits/memoryfwd.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 63 "/usr/include/c++/10/bits/memoryfwd.h" 3 template class allocator; # 73 "/usr/include/c++/10/bits/memoryfwd.h" 3 template struct uses_allocator; } # 41 "/usr/include/c++/10/bits/stringfwd.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct char_traits; template<> struct char_traits; template<> struct char_traits; template<> struct char_traits; template<> struct char_traits; template<> struct char_traits; namespace __cxx11 { template, typename _Alloc = allocator<_CharT> > class basic_string; } typedef basic_string string; typedef basic_string wstring; typedef basic_string u8string; typedef basic_string u16string; typedef basic_string u32string; } # 40 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/char_traits.h" 1 3 # 37 "/usr/include/c++/10/bits/char_traits.h" 3 # 38 "/usr/include/c++/10/bits/char_traits.h" 3 # 1 "/usr/include/c++/10/bits/stl_algobase.h" 1 3 # 60 "/usr/include/c++/10/bits/stl_algobase.h" 3 # 1 "/usr/include/c++/10/bits/functexcept.h" 1 3 # 42 "/usr/include/c++/10/bits/functexcept.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { void __throw_bad_exception(void) __attribute__((__noreturn__)); void __throw_bad_alloc(void) __attribute__((__noreturn__)); void __throw_bad_cast(void) __attribute__((__noreturn__)); void __throw_bad_typeid(void) __attribute__((__noreturn__)); void __throw_logic_error(const char*) __attribute__((__noreturn__)); void __throw_domain_error(const char*) __attribute__((__noreturn__)); void __throw_invalid_argument(const char*) __attribute__((__noreturn__)); void __throw_length_error(const char*) __attribute__((__noreturn__)); void __throw_out_of_range(const char*) __attribute__((__noreturn__)); void __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) __attribute__((__format__(__gnu_printf__, 1, 2))); void __throw_runtime_error(const char*) __attribute__((__noreturn__)); void __throw_range_error(const char*) __attribute__((__noreturn__)); void __throw_overflow_error(const char*) __attribute__((__noreturn__)); void __throw_underflow_error(const char*) __attribute__((__noreturn__)); void __throw_ios_failure(const char*) __attribute__((__noreturn__)); void __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); void __throw_system_error(int) __attribute__((__noreturn__)); void __throw_future_error(int) __attribute__((__noreturn__)); void __throw_bad_function_call() __attribute__((__noreturn__)); } # 61 "/usr/include/c++/10/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 1 3 # 62 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 # 63 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 # 71 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 # 1 "/usr/include/c++/10/bits/iterator_concepts.h" 1 3 # 33 "/usr/include/c++/10/bits/iterator_concepts.h" 3 # 34 "/usr/include/c++/10/bits/iterator_concepts.h" 3 # 1 "/usr/include/c++/10/bits/ptr_traits.h" 1 3 # 39 "/usr/include/c++/10/bits/ptr_traits.h" 3 namespace __gnu_debug { struct _Safe_iterator_base; } namespace std __attribute__ ((__visibility__ ("default"))) { class __undefined; template struct __get_first_arg { using type = __undefined; }; template class _Template, typename _Tp, typename... _Types> struct __get_first_arg<_Template<_Tp, _Types...>> { using type = _Tp; }; template using __get_first_arg_t = typename __get_first_arg<_Tp>::type; template struct __replace_first_arg { }; template class _Template, typename _Up, typename _Tp, typename... _Types> struct __replace_first_arg<_Template<_Tp, _Types...>, _Up> { using type = _Template<_Up, _Types...>; }; template using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type; template using __make_not_void = typename conditional::value, __undefined, _Tp>::type; template struct pointer_traits { private: template using __element_type = typename _Tp::element_type; template using __difference_type = typename _Tp::difference_type; template struct __rebind : __replace_first_arg<_Tp, _Up> { }; template struct __rebind<_Tp, _Up, __void_t>> { using type = typename _Tp::template rebind<_Up>; }; public: using pointer = _Ptr; using element_type = __detected_or_t<__get_first_arg_t<_Ptr>, __element_type, _Ptr>; using difference_type = __detected_or_t; template using rebind = typename __rebind<_Ptr, _Up>::type; static _Ptr pointer_to(__make_not_void& __e) { return _Ptr::pointer_to(__e); } static_assert(!is_same::value, "pointer type defines element_type or is like SomePointer"); }; template struct pointer_traits<_Tp*> { typedef _Tp* pointer; typedef _Tp element_type; typedef ptrdiff_t difference_type; template using rebind = _Up*; static constexpr pointer pointer_to(__make_not_void& __r) noexcept { return std::addressof(__r); } }; template using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; template constexpr _Tp* __to_address(_Tp* __ptr) noexcept { static_assert(!std::is_function<_Tp>::value, "not a function pointer"); return __ptr; } template constexpr auto __to_address(const _Ptr& __ptr) noexcept -> decltype(std::pointer_traits<_Ptr>::to_address(__ptr)) { return std::pointer_traits<_Ptr>::to_address(__ptr); } template 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->()); } # 192 "/usr/include/c++/10/bits/ptr_traits.h" 3 template constexpr _Tp* to_address(_Tp* __ptr) noexcept { return std::__to_address(__ptr); } # 204 "/usr/include/c++/10/bits/ptr_traits.h" 3 template constexpr auto to_address(const _Ptr& __ptr) noexcept { return std::__to_address(__ptr); } } # 37 "/usr/include/c++/10/bits/iterator_concepts.h" 2 3 # 1 "/usr/include/c++/10/bits/range_cmp.h" 1 3 # 37 "/usr/include/c++/10/bits/range_cmp.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct __is_transparent; struct identity { template constexpr _Tp&& operator()(_Tp&& __t) const noexcept { return std::forward<_Tp>(__t); } using is_transparent = __is_transparent; }; namespace ranges { namespace __detail { template concept __less_builtin_ptr_cmp = requires (_Tp&& __t, _Up&& __u) { { __t < __u } -> same_as; } && 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 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 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 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( static_cast(std::forward<_Tp>(__t))); auto __y = reinterpret_cast( static_cast(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 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 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 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; }; } } # 38 "/usr/include/c++/10/bits/iterator_concepts.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { 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 struct iterator_traits; template requires is_object_v<_Tp> struct iterator_traits<_Tp*>; template struct __iterator_traits; namespace __detail { template using __with_ref = _Tp&; template concept __can_reference = requires { typename __with_ref<_Tp>; }; template concept __dereferenceable = requires(_Tp& __t) { { *__t } -> __can_reference; }; } template<__detail::__dereferenceable _Tp> using iter_reference_t = decltype(*std::declval<_Tp&>()); namespace ranges { namespace __cust_imove { void iter_move(); template concept __adl_imove = (std::__detail::__class_or_enum>) && requires(_Tp&& __t) { iter_move(static_cast<_Tp&&>(__t)); }; struct _IMove { private: template struct __result { using type = iter_reference_t<_Tp>; }; template requires __adl_imove<_Tp> struct __result<_Tp> { using type = decltype(iter_move(std::declval<_Tp>())); }; template requires (!__adl_imove<_Tp>) && is_lvalue_reference_v> struct __result<_Tp> { using type = remove_reference_t>&&; }; template 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 using __type = typename __result<_Tp>::type; template 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>) return static_cast<__type<_Tp>>(*__e); else return *__e; } }; } inline namespace __cust { inline constexpr __cust_imove::_IMove iter_move{}; } } template<__detail::__dereferenceable _Tp> requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __detail::__can_reference; } using iter_rvalue_reference_t = decltype(ranges::iter_move(std::declval<_Tp&>())); template struct incrementable_traits { }; template requires is_object_v<_Tp> struct incrementable_traits<_Tp*> { using difference_type = ptrdiff_t; }; template struct incrementable_traits : incrementable_traits<_Iter> { }; template requires requires { typename _Tp::difference_type; } struct incrementable_traits<_Tp> { using difference_type = typename _Tp::difference_type; }; template requires (!requires { typename _Tp::difference_type; } && requires(const _Tp& __a, const _Tp& __b) { requires (!is_void_v>); { __a - __b } -> integral; }) struct incrementable_traits<_Tp> { using difference_type = make_signed_t() - std::declval<_Tp>())>; }; template<> struct incrementable_traits<__int128> { using difference_type = __int128; }; template<> struct incrementable_traits { using difference_type = __int128; }; namespace __detail { template concept __primary_traits_iter = __is_base_of(__iterator_traits<_Iter, void>, iterator_traits<_Iter>); template struct __iter_traits_impl { using type = iterator_traits<_Iter>; }; template requires __primary_traits_iter<_Iter> struct __iter_traits_impl<_Iter, _Tp> { using type = _Tp; }; template using __iter_traits = typename __iter_traits_impl<_Iter, _Tp>::type; template using __iter_diff_t = typename __iter_traits<_Tp, incrementable_traits<_Tp>>::difference_type; } template using iter_difference_t = __detail::__iter_diff_t>; namespace __detail { template struct __cond_value_type { }; template requires is_object_v<_Tp> struct __cond_value_type<_Tp> { using value_type = remove_cv_t<_Tp>; }; } template struct indirectly_readable_traits { }; template struct indirectly_readable_traits<_Tp*> : __detail::__cond_value_type<_Tp> { }; template requires is_array_v<_Iter> struct indirectly_readable_traits<_Iter> { using value_type = remove_cv_t>; }; template struct indirectly_readable_traits : indirectly_readable_traits<_Iter> { }; template requires requires { typename _Tp::value_type; } struct indirectly_readable_traits<_Tp> : __detail::__cond_value_type { }; template requires requires { typename _Tp::element_type; } struct indirectly_readable_traits<_Tp> : __detail::__cond_value_type { }; namespace __detail { template using __iter_value_t = typename __iter_traits<_Tp, indirectly_readable_traits<_Tp>>::value_type; } template using iter_value_t = __detail::__iter_value_t>; namespace __detail { template concept __cpp17_iterator = requires(_Iter __it) { { *__it } -> __can_reference; { ++__it } -> same_as<_Iter&>; { *__it++ } -> __can_reference; } && copyable<_Iter>; template 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&&, typename indirectly_readable_traits<_Iter>::value_type&>; typename common_reference_t::value_type&>; requires signed_integral< typename incrementable_traits<_Iter>::difference_type>; }; template concept __cpp17_fwd_iterator = __cpp17_input_iterator<_Iter> && constructible_from<_Iter> && is_lvalue_reference_v> && same_as>, typename indirectly_readable_traits<_Iter>::value_type> && requires(_Iter __it) { { __it++ } -> convertible_to; { *__it++ } -> same_as>; }; template concept __cpp17_bidi_iterator = __cpp17_fwd_iterator<_Iter> && requires(_Iter __it) { { --__it } -> same_as<_Iter&>; { __it-- } -> convertible_to; { *__it-- } -> same_as>; }; template 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; { __it[__n] } -> convertible_to>; }; template concept __iter_with_nested_types = requires { typename _Iter::iterator_category; typename _Iter::value_type; typename _Iter::difference_type; typename _Iter::reference; }; template concept __iter_without_nested_types = !__iter_with_nested_types<_Iter>; template concept __iter_without_category = !requires { typename _Iter::iterator_category; }; } template requires __detail::__iter_with_nested_types<_Iterator> struct __iterator_traits<_Iterator, void> { private: template struct __ptr { using type = void; }; template 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 requires __detail::__iter_without_nested_types<_Iterator> && __detail::__cpp17_input_iterator<_Iterator> struct __iterator_traits<_Iterator, void> { private: template struct __cat { using type = input_iterator_tag; }; template requires requires { typename _Iter::iterator_category; } struct __cat<_Iter> { using type = typename _Iter::iterator_category; }; template requires __detail::__iter_without_category<_Iter> && __detail::__cpp17_randacc_iterator<_Iter> struct __cat<_Iter> { using type = random_access_iterator_tag; }; template requires __detail::__iter_without_category<_Iter> && __detail::__cpp17_bidi_iterator<_Iter> struct __cat<_Iter> { using type = bidirectional_iterator_tag; }; template requires __detail::__iter_without_category<_Iter> && __detail::__cpp17_fwd_iterator<_Iter> struct __cat<_Iter> { using type = forward_iterator_tag; }; template struct __ptr { using type = void; }; template requires requires { typename _Iter::pointer; } struct __ptr<_Iter> { using type = typename _Iter::pointer; }; template requires (!requires { typename _Iter::pointer; } && requires(_Iter& __it) { __it.operator->(); }) struct __ptr<_Iter> { using type = decltype(std::declval<_Iter&>().operator->()); }; template struct __ref { using type = iter_reference_t<_Iter>; }; template 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 requires __detail::__iter_without_nested_types<_Iterator> && __detail::__cpp17_iterator<_Iterator> struct __iterator_traits<_Iterator, void> { private: template struct __diff { using type = void; }; template 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 struct __iter_concept_impl; template requires requires { typename __iter_traits<_Iter>::iterator_concept; } struct __iter_concept_impl<_Iter> { using type = typename __iter_traits<_Iter>::iterator_concept; }; template 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 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 struct __iter_concept_impl { }; template using __iter_concept = typename __iter_concept_impl<_Iter>::type; template concept __indirectly_readable_impl = requires(const _In __in) { typename iter_value_t<_In>; typename iter_reference_t<_In>; typename iter_rvalue_reference_t<_In>; { *__in } -> same_as>; { ranges::iter_move(__in) } -> same_as>; } && common_reference_with&&, iter_value_t<_In>&> && common_reference_with&&, iter_rvalue_reference_t<_In>&&> && common_reference_with&&, const iter_value_t<_In>&>; } template concept indirectly_readable = __detail::__indirectly_readable_impl>; template using iter_common_reference_t = common_reference_t, iter_value_t<_Tp>&>; template concept indirectly_writable = requires(_Out&& __o, _Tp&& __t) { *__o = std::forward<_Tp>(__t); *std::forward<_Out>(__o) = std::forward<_Tp>(__t); const_cast&&>(*__o) = std::forward<_Tp>(__t); const_cast&&>(*std::forward<_Out>(__o)) = std::forward<_Tp>(__t); }; namespace ranges::__detail { using __max_diff_type = __int128; using __max_size_type = unsigned __int128; template concept __is_integer_like = integral<_Tp> || same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>; template concept __is_signed_integer_like = signed_integral<_Tp> || same_as<_Tp, __max_diff_type>; } namespace __detail { using ranges::__detail::__is_signed_integer_like; } template concept weakly_incrementable = default_initializable<_Iter> && movable<_Iter> && requires(_Iter __i) { typename iter_difference_t<_Iter>; requires __detail::__is_signed_integer_like>; { ++__i } -> same_as<_Iter&>; __i++; }; template concept incrementable = regular<_Iter> && weakly_incrementable<_Iter> && requires(_Iter __i) { { __i++ } -> same_as<_Iter>; }; template concept input_or_output_iterator = requires(_Iter __i) { { *__i } -> __detail::__can_reference; } && weakly_incrementable<_Iter>; template concept sentinel_for = semiregular<_Sent> && input_or_output_iterator<_Iter> && __detail::__weakly_eq_cmp_with<_Sent, _Iter>; template inline constexpr bool disable_sized_sentinel_for = false; template concept sized_sentinel_for = sentinel_for<_Sent, _Iter> && !disable_sized_sentinel_for, remove_cv_t<_Iter>> && requires(const _Iter& __i, const _Sent& __s) { { __s - __i } -> same_as>; { __i - __s } -> same_as>; }; template 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 concept output_iterator = input_or_output_iterator<_Iter> && indirectly_writable<_Iter, _Tp> && requires(_Iter __i, _Tp&& __t) { *__i++ = std::forward<_Tp>(__t); }; template concept forward_iterator = input_iterator<_Iter> && derived_from<__detail::__iter_concept<_Iter>, forward_iterator_tag> && incrementable<_Iter> && sentinel_for<_Iter, _Iter>; template 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 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>; }; template concept contiguous_iterator = random_access_iterator<_Iter> && derived_from<__detail::__iter_concept<_Iter>, contiguous_iterator_tag> && is_lvalue_reference_v> && same_as, remove_cvref_t>> && requires(const _Iter& __i) { { std::to_address(__i) } -> same_as>>; }; template 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_reference_t<_Iter>>>; template 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_reference_t<_Iter>>>; template 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 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 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 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 requires (indirectly_readable<_Is> && ...) && invocable<_Fn, iter_reference_t<_Is>...> using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Is>...>; template _Proj> struct projected { using value_type = remove_cvref_t>; indirect_result_t<_Proj&, _Iter> operator*() const; }; template struct incrementable_traits> { using difference_type = iter_difference_t<_Iter>; }; template concept indirectly_movable = indirectly_readable<_In> && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>; template concept indirectly_movable_storable = indirectly_movable<_In, _Out> && indirectly_writable<_Out, iter_value_t<_In>> && movable> && constructible_from, iter_rvalue_reference_t<_In>> && assignable_from&, iter_rvalue_reference_t<_In>>; template concept indirectly_copyable = indirectly_readable<_In> && indirectly_writable<_Out, iter_reference_t<_In>>; template 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> && constructible_from, iter_reference_t<_In>> && assignable_from&, iter_reference_t<_In>>; namespace ranges { namespace __cust_iswap { template void iter_swap(_It1, _It2) = delete; template concept __adl_iswap = (std::__detail::__class_or_enum> || std::__detail::__class_or_enum>) && requires(_Tp&& __t, _Up&& __u) { iter_swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }; template 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 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<_Up>>) return noexcept(ranges::swap(*std::declval<_Tp>(), *std::declval<_Up>())); else return noexcept(*std::declval<_Tp>() = __iter_exchange_move(std::declval<_Up>(), std::declval<_Tp>())); } public: template requires __adl_iswap<_Tp, _Up> || (indirectly_readable> && indirectly_readable> && swappable_with, 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<_Up>>) ranges::swap(*__e1, *__e2); else *__e1 = __iter_exchange_move(__e2, __e1); } }; } inline namespace __cust { inline constexpr __cust_iswap::_IterSwap iter_swap{}; } } template 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 concept indirectly_comparable = indirect_binary_predicate<_Rel, projected<_I1, _P1>, projected<_I2, _P2>>; template concept permutable = forward_iterator<_Iter> && indirectly_movable_storable<_Iter, _Iter> && indirectly_swappable<_Iter, _Iter>; template 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 concept sortable = permutable<_Iter> && indirect_strict_weak_order<_Rel, projected<_Iter, _Proj>>; struct unreachable_sentinel_t { template friend constexpr bool operator==(unreachable_sentinel_t, const _It&) noexcept { return false; } }; inline constexpr unreachable_sentinel_t unreachable_sentinel{}; struct default_sentinel_t { }; inline constexpr default_sentinel_t default_sentinel{}; namespace __detail { template constexpr decay_t<_Tp> __decay_copy(_Tp&& __t) noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>) { return std::forward<_Tp>(__t); } template concept __member_begin = requires(_Tp& __t) { { __detail::__decay_copy(__t.begin()) } -> input_or_output_iterator; }; void begin(auto&) = delete; void begin(const auto&) = delete; template concept __adl_begin = __class_or_enum> && requires(_Tp& __t) { { __detail::__decay_copy(begin(__t)) } -> input_or_output_iterator; }; template requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&> auto __ranges_begin(_Tp& __t) { if constexpr (is_array_v<_Tp>) { static_assert(sizeof(remove_all_extents_t<_Tp>) != 0, "not array of incomplete type"); return __t + 0; } else if constexpr (__member_begin<_Tp&>) return __t.begin(); else return begin(__t); } template using __range_iter_t = decltype(__detail::__ranges_begin(std::declval<_Tp&>())); } } # 72 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 93 "/usr/include/c++/10/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 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 template struct iterator { typedef _Category iterator_category; typedef _Tp value_type; typedef _Distance difference_type; typedef _Pointer pointer; typedef _Reference reference; }; # 149 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 template struct iterator_traits; template> struct __iterator_traits { }; # 176 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 template struct iterator_traits : public __iterator_traits<_Iterator> { }; # 194 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 template 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 "/usr/include/c++/10/bits/stl_iterator_base_types.h" 3 template inline constexpr typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&) { return typename iterator_traits<_Iter>::iterator_category(); } template using __iterator_category_t = typename iterator_traits<_Iter>::iterator_category; template using _RequireInputIter = __enable_if_t, input_iterator_tag>::value>; template> struct __is_random_access_iter : is_base_of { typedef is_base_of _Base; enum { __value = _Base::value }; }; } # 66 "/usr/include/c++/10/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 1 3 # 62 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3 # 63 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3 # 1 "/usr/include/c++/10/bits/concept_check.h" 1 3 # 33 "/usr/include/c++/10/bits/concept_check.h" 3 # 34 "/usr/include/c++/10/bits/concept_check.h" 3 # 65 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 2 3 # 1 "/usr/include/c++/10/debug/assertions.h" 1 3 # 66 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct _List_iterator; template struct _List_const_iterator; template inline constexpr typename iterator_traits<_InputIterator>::difference_type __distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) { typename iterator_traits<_InputIterator>::difference_type __n = 0; while (__first != __last) { ++__first; ++__n; } return __n; } template inline constexpr typename iterator_traits<_RandomAccessIterator>::difference_type __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) { return __last - __first; } template ptrdiff_t __distance(std::_List_iterator<_Tp>, std::_List_iterator<_Tp>, input_iterator_tag); template ptrdiff_t __distance(std::_List_const_iterator<_Tp>, std::_List_const_iterator<_Tp>, input_iterator_tag); # 135 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3 template inline constexpr typename iterator_traits<_InputIterator>::difference_type distance(_InputIterator __first, _InputIterator __last) { return std::__distance(__first, __last, std::__iterator_category(__first)); } template inline constexpr void __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) { ; while (__n--) ++__i; } template inline constexpr void __advance(_BidirectionalIterator& __i, _Distance __n, bidirectional_iterator_tag) { if (__n > 0) while (__n--) ++__i; else while (__n++) --__i; } template inline constexpr void __advance(_RandomAccessIterator& __i, _Distance __n, random_access_iterator_tag) { if (__builtin_constant_p(__n) && __n == 1) ++__i; else if (__builtin_constant_p(__n) && __n == -1) --__i; else __i += __n; } # 200 "/usr/include/c++/10/bits/stl_iterator_base_funcs.h" 3 template 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 inline constexpr _InputIterator next(_InputIterator __x, typename iterator_traits<_InputIterator>::difference_type __n = 1) { std::advance(__x, __n); return __x; } template inline constexpr _BidirectionalIterator prev(_BidirectionalIterator __x, typename iterator_traits<_BidirectionalIterator>::difference_type __n = 1) { std::advance(__x, -__n); return __x; } } # 67 "/usr/include/c++/10/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/10/bits/stl_iterator.h" 1 3 # 85 "/usr/include/c++/10/bits/stl_iterator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template using __clamp_iter_cat = conditional_t, _Limit, _Otherwise>; } # 124 "/usr/include/c++/10/bits/stl_iterator.h" 3 template class reverse_iterator : public iterator::iterator_category, typename iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::reference> { protected: _Iterator current; typedef iterator_traits<_Iterator> __traits_type; public: typedef _Iterator iterator_type; typedef typename __traits_type::difference_type difference_type; typedef typename __traits_type::pointer pointer; typedef typename __traits_type::reference reference; using iterator_concept = conditional_t, random_access_iterator_tag, bidirectional_iterator_tag>; using iterator_category = __detail::__clamp_iter_cat; # 160 "/usr/include/c++/10/bits/stl_iterator.h" 3 constexpr reverse_iterator() : current() { } explicit constexpr reverse_iterator(iterator_type __x) : current(__x) { } constexpr reverse_iterator(const reverse_iterator& __x) : current(__x.current) { } reverse_iterator& operator=(const reverse_iterator&) = default; template constexpr reverse_iterator(const reverse_iterator<_Iter>& __x) : current(__x.base()) { } constexpr iterator_type base() const { return current; } # 206 "/usr/include/c++/10/bits/stl_iterator.h" 3 constexpr reference operator*() const { _Iterator __tmp = current; return *--__tmp; } 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; } constexpr reverse_iterator operator+(difference_type __n) const { return reverse_iterator(current - __n); } constexpr reverse_iterator& operator+=(difference_type __n) { current -= __n; return *this; } constexpr reverse_iterator operator-(difference_type __n) const { return reverse_iterator(current + __n); } constexpr reverse_iterator& operator-=(difference_type __n) { current += __n; return *this; } constexpr reference operator[](difference_type __n) const { return *(*this + __n); } 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 _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 static constexpr _Tp* _S_to_pointer(_Tp* __p) { return __p; } template static constexpr pointer _S_to_pointer(_Tp __t) { return __t.operator->(); } }; # 457 "/usr/include/c++/10/bits/stl_iterator.h" 3 template constexpr bool operator==(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) requires requires { { __x.base() == __y.base() } -> convertible_to; } { return __x.base() == __y.base(); } template constexpr bool operator!=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) requires requires { { __x.base() != __y.base() } -> convertible_to; } { return __x.base() != __y.base(); } template constexpr bool operator<(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) requires requires { { __x.base() > __y.base() } -> convertible_to; } { return __x.base() > __y.base(); } template constexpr bool operator>(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) requires requires { { __x.base() < __y.base() } -> convertible_to; } { return __x.base() < __y.base(); } template constexpr bool operator<=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) requires requires { { __x.base() >= __y.base() } -> convertible_to; } { return __x.base() >= __y.base(); } template constexpr bool operator>=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) requires requires { { __x.base() <= __y.base() } -> convertible_to; } { return __x.base() <= __y.base(); } template _IteratorR> constexpr compare_three_way_result_t<_IteratorL, _IteratorR> operator<=>(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __y.base() <=> __x.base(); } # 523 "/usr/include/c++/10/bits/stl_iterator.h" 3 template 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 inline constexpr reverse_iterator<_Iterator> operator+(typename reverse_iterator<_Iterator>::difference_type __n, const reverse_iterator<_Iterator>& __x) { return reverse_iterator<_Iterator>(__x.base() - __n); } template inline constexpr reverse_iterator<_Iterator> __make_reverse_iterator(_Iterator __i) { return reverse_iterator<_Iterator>(__i); } template inline constexpr reverse_iterator<_Iterator> make_reverse_iterator(_Iterator __i) { return reverse_iterator<_Iterator>(__i); } template requires (!sized_sentinel_for<_Iterator1, _Iterator2>) inline constexpr bool disable_sized_sentinel_for, reverse_iterator<_Iterator2>> = true; template 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 struct __is_move_iterator > : __is_move_iterator<_Iterator> { }; template constexpr auto __miter_base(reverse_iterator<_Iterator> __it) -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) { return __make_reverse_iterator(__miter_base(__it.base())); } # 595 "/usr/include/c++/10/bits/stl_iterator.h" 3 template class back_insert_iterator : public iterator { protected: _Container* container; public: typedef _Container container_type; using difference_type = ptrdiff_t; constexpr back_insert_iterator() noexcept : container(nullptr) { } explicit constexpr back_insert_iterator(_Container& __x) : container(std::__addressof(__x)) { } # 635 "/usr/include/c++/10/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; } constexpr back_insert_iterator& operator*() { return *this; } constexpr back_insert_iterator& operator++() { return *this; } constexpr back_insert_iterator operator++(int) { return *this; } }; # 682 "/usr/include/c++/10/bits/stl_iterator.h" 3 template constexpr inline back_insert_iterator<_Container> back_inserter(_Container& __x) { return back_insert_iterator<_Container>(__x); } # 698 "/usr/include/c++/10/bits/stl_iterator.h" 3 template class front_insert_iterator : public iterator { protected: _Container* container; public: typedef _Container container_type; using difference_type = ptrdiff_t; constexpr front_insert_iterator() noexcept : container(nullptr) { } explicit constexpr front_insert_iterator(_Container& __x) : container(std::__addressof(__x)) { } # 738 "/usr/include/c++/10/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; } constexpr front_insert_iterator& operator*() { return *this; } constexpr front_insert_iterator& operator++() { return *this; } constexpr front_insert_iterator operator++(int) { return *this; } }; # 785 "/usr/include/c++/10/bits/stl_iterator.h" 3 template constexpr inline front_insert_iterator<_Container> front_inserter(_Container& __x) { return front_insert_iterator<_Container>(__x); } # 805 "/usr/include/c++/10/bits/stl_iterator.h" 3 template class insert_iterator : public iterator { using _Iter = std::__detail::__range_iter_t<_Container>; protected: _Container* container = nullptr; _Iter iter = _Iter(); # 823 "/usr/include/c++/10/bits/stl_iterator.h" 3 public: typedef _Container container_type; using difference_type = ptrdiff_t; insert_iterator() = default; constexpr insert_iterator(_Container& __x, _Iter __i) : container(std::__addressof(__x)), iter(__i) {} # 873 "/usr/include/c++/10/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; } constexpr insert_iterator& operator*() { return *this; } constexpr insert_iterator& operator++() { return *this; } constexpr insert_iterator& operator++(int) { return *this; } }; # 924 "/usr/include/c++/10/bits/stl_iterator.h" 3 template constexpr insert_iterator<_Container> inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i) { return insert_iterator<_Container>(__x, __i); } # 937 "/usr/include/c++/10/bits/stl_iterator.h" 3 } namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 951 "/usr/include/c++/10/bits/stl_iterator.h" 3 template class __normal_iterator { protected: _Iterator _M_current; typedef std::iterator_traits<_Iterator> __traits_type; public: typedef _Iterator iterator_type; typedef typename __traits_type::iterator_category iterator_category; typedef typename __traits_type::value_type value_type; typedef typename __traits_type::difference_type difference_type; typedef typename __traits_type::reference reference; typedef typename __traits_type::pointer pointer; 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 constexpr __normal_iterator(const __normal_iterator<_Iter, typename __enable_if< (std::__are_same<_Iter, typename _Container::pointer>::__value), _Container>::__type>& __i) noexcept : _M_current(__i.base()) { } 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; } }; # 1066 "/usr/include/c++/10/bits/stl_iterator.h" 3 template requires requires (_IteratorL __lhs, _IteratorR __rhs) { { __lhs == __rhs } -> std::convertible_to; } constexpr bool operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept(noexcept(__lhs.base() == __rhs.base())) { return __lhs.base() == __rhs.base(); } template 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()); } # 1181 "/usr/include/c++/10/bits/stl_iterator.h" 3 template 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 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 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 __attribute__ ((__visibility__ ("default"))) { template constexpr _Iterator __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) { return __it.base(); } # 1233 "/usr/include/c++/10/bits/stl_iterator.h" 3 template 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 requires convertible_to constexpr move_sentinel(const move_sentinel<_S2>& __s) noexcept(is_nothrow_constructible_v<_Sent, const _S2&>) : _M_last(__s.base()) { } template 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; } constexpr _Sent base() const noexcept(is_nothrow_copy_constructible_v<_Sent>) { return _M_last; } private: _Sent _M_last; }; # 1282 "/usr/include/c++/10/bits/stl_iterator.h" 3 template class move_iterator { _Iterator _M_current; using __traits_type = iterator_traits<_Iterator>; using __base_cat = typename __traits_type::iterator_category; public: using iterator_type = _Iterator; using iterator_concept = input_iterator_tag; using iterator_category = __detail::__clamp_iter_cat<__base_cat, random_access_iterator_tag>; using value_type = iter_value_t<_Iterator>; using difference_type = iter_difference_t<_Iterator>; using pointer = _Iterator; using reference = iter_rvalue_reference_t<_Iterator>; # 1318 "/usr/include/c++/10/bits/stl_iterator.h" 3 constexpr move_iterator() : _M_current() { } explicit constexpr move_iterator(iterator_type __i) : _M_current(std::move(__i)) { } template constexpr move_iterator(const move_iterator<_Iter>& __i) : _M_current(__i.base()) { } template constexpr move_iterator& operator=(const move_iterator<_Iter>& __i) { _M_current = __i.base(); return *this; } constexpr iterator_type base() const & requires copy_constructible { return _M_current; } constexpr iterator_type base() && { return std::move(_M_current); } constexpr reference operator*() const { return ranges::iter_move(_M_current); } constexpr pointer operator->() const { return _M_current; } constexpr move_iterator& operator++() { ++_M_current; return *this; } constexpr move_iterator operator++(int) { move_iterator __tmp = *this; ++_M_current; return __tmp; } constexpr 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; } constexpr move_iterator operator+(difference_type __n) const { return move_iterator(_M_current + __n); } constexpr move_iterator& operator+=(difference_type __n) { _M_current += __n; return *this; } constexpr move_iterator operator-(difference_type __n) const { return move_iterator(_M_current - __n); } constexpr move_iterator& operator-=(difference_type __n) { _M_current -= __n; return *this; } constexpr reference operator[](difference_type __n) const { return ranges::iter_move(_M_current + __n); } template _Sent> friend constexpr bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y) { return __x.base() == __y.base(); } template _Sent> friend constexpr iter_difference_t<_Iterator> operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y) { return __x.base() - __y.base(); } template _Sent> friend constexpr iter_difference_t<_Iterator> operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y) { return __x.base() - __y.base(); } 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 _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 inline constexpr bool operator==(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) requires requires { { __x.base() == __y.base() } -> convertible_to; } { return __x.base() == __y.base(); } template _IteratorR> constexpr compare_three_way_result_t<_IteratorL, _IteratorR> operator<=>(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) { return __x.base() <=> __y.base(); } # 1487 "/usr/include/c++/10/bits/stl_iterator.h" 3 template inline constexpr bool operator<(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) requires requires { { __x.base() < __y.base() } -> convertible_to; } { return __x.base() < __y.base(); } template inline constexpr bool operator<=(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) requires requires { { __y.base() < __x.base() } -> convertible_to; } { return !(__y < __x); } template inline constexpr bool operator>(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) requires requires { { __y.base() < __x.base() } -> convertible_to; } { return __y < __x; } template inline constexpr bool operator>=(const move_iterator<_IteratorL>& __x, const move_iterator<_IteratorR>& __y) requires requires { { __x.base() < __y.base() } -> convertible_to; } { return !(__x < __y); } # 1569 "/usr/include/c++/10/bits/stl_iterator.h" 3 template 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 inline constexpr move_iterator<_Iterator> operator+(typename move_iterator<_Iterator>::difference_type __n, const move_iterator<_Iterator>& __x) { return __x + __n; } template inline constexpr move_iterator<_Iterator> make_move_iterator(_Iterator __i) { return move_iterator<_Iterator>(std::move(__i)); } template::value_type>::value, _Iterator, move_iterator<_Iterator>>::type> inline constexpr _ReturnType __make_move_if_noexcept_iterator(_Iterator __i) { return _ReturnType(__i); } template::value, const _Tp*, move_iterator<_Tp*>>::type> inline constexpr _ReturnType __make_move_if_noexcept_iterator(_Tp* __i) { return _ReturnType(__i); } namespace __detail { template concept __common_iter_has_arrow = indirectly_readable && (requires(const _It& __it) { __it.operator->(); } || is_reference_v> || constructible_from, iter_reference_t<_It>>); } template _Sent> requires (!same_as<_It, _Sent>) && copyable<_It> class common_iterator { template 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 static constexpr bool _S_noexcept() { return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); } class _Proxy { iter_value_t<_It> _M_keep; _Proxy(iter_reference_t<_It>&& __x) : _M_keep(std::move(__x)) { } friend class common_iterator; public: const iter_value_t<_It>* operator->() const { return std::__addressof(_M_keep); } }; public: constexpr common_iterator() noexcept(is_nothrow_default_constructible_v<_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 requires convertible_to && convertible_to constexpr common_iterator(const common_iterator<_It2, _Sent2>& __x) noexcept(_S_noexcept()) : _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 ::new((void*)std::__addressof(_M_it)) _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 ::new((void*)std::__addressof(_M_sent)) _Sent(__x._M_sent); } } constexpr common_iterator(const common_iterator& __x) noexcept(_S_noexcept()) : _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 ::new((void*)std::__addressof(_M_it)) _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 ::new((void*)std::__addressof(_M_sent)) _Sent(__x._M_sent); } } 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>) { return this->operator=<_It, _Sent>(__x); } template requires convertible_to && convertible_to && assignable_from<_It&, const _It2&> && assignable_from<_Sent&, const _Sent2&> 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&>) { switch(_M_index << 2 | __x._M_index) { case 0b0000: _M_it = __x._M_it; break; case 0b0101: _M_sent = __x._M_sent; break; case 0b0001: _M_it.~_It(); _M_index = -1; [[fallthrough]]; case 0b1001: ::new((void*)std::__addressof(_M_sent)) _Sent(__x._M_sent); _M_index = 1; break; case 0b0100: _M_sent.~_Sent(); _M_index = -1; [[fallthrough]]; case 0b1000: ::new((void*)std::__addressof(_M_it)) _It(__x._M_it); _M_index = 0; break; default: ; __builtin_unreachable(); } return *this; } ~common_iterator() { switch (_M_index) { case 0: _M_it.~_It(); break; case 1: _M_sent.~_Sent(); break; } } decltype(auto) operator*() { ; return *_M_it; } decltype(auto) operator*() const requires __detail::__dereferenceable { ; return *_M_it; } decltype(auto) operator->() const requires __detail::__common_iter_has_arrow<_It> { ; if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); }) return _M_it; else if constexpr (is_reference_v>) { auto&& __tmp = *_M_it; return std::__addressof(__tmp); } else return _Proxy{*_M_it}; } common_iterator& operator++() { ; ++_M_it; return *this; } decltype(auto) operator++(int) { ; if constexpr (forward_iterator<_It>) { common_iterator __tmp = *this; ++*this; return __tmp; } else return _M_it++; } template _Sent2> requires sentinel_for<_Sent, _It2> friend bool operator==(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: ; ; __builtin_unreachable(); } } template _Sent2> requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2> friend bool operator==(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: ; ; __builtin_unreachable(); } } template _It2, sized_sentinel_for<_It> _Sent2> requires sized_sentinel_for<_Sent, _It2> friend iter_difference_t<_It2> operator-(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: ; ; __builtin_unreachable(); } } friend iter_rvalue_reference_t<_It> iter_move(const common_iterator& __i) noexcept(noexcept(ranges::iter_move(std::declval()))) requires input_iterator<_It> { ; return ranges::iter_move(__i._M_it); } template _It2, typename _Sent2> friend void iter_swap(const common_iterator& __x, const common_iterator<_It2, _Sent2>& __y) noexcept(noexcept(ranges::iter_swap(std::declval(), std::declval()))) { ; ; return ranges::iter_swap(__x._M_it, __y._M_it); } private: template _Sent2> friend class common_iterator; bool _M_has_value() const noexcept { return _M_index < 2; } union { _It _M_it; _Sent _M_sent; unsigned char _M_valueless; }; unsigned char _M_index; }; template struct incrementable_traits> { using difference_type = iter_difference_t<_It>; }; template struct iterator_traits> { private: template struct __ptr { using type = void; }; template requires __detail::__common_iter_has_arrow<_Iter> struct __ptr<_Iter> { using _CIter = common_iterator<_Iter, _Sent>; using type = decltype(std::declval().operator->()); }; public: using iterator_concept = conditional_t, forward_iterator_tag, input_iterator_tag>; using iterator_category = __detail::__clamp_iter_cat< typename iterator_traits<_It>::iterator_category, forward_iterator_tag, input_iterator_tag>; 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>; }; template class counted_iterator { public: using iterator_type = _It; constexpr counted_iterator() = default; constexpr counted_iterator(_It __i, iter_difference_t<_It> __n) : _M_current(std::move(__i)), _M_length(__n) { ; } template requires convertible_to constexpr counted_iterator(const counted_iterator<_It2>& __x) : _M_current(__x._M_current), _M_length(__x._M_length) { } template 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; } constexpr _It base() const & noexcept(is_nothrow_copy_constructible_v<_It>) requires copy_constructible<_It> { return _M_current; } constexpr _It base() && noexcept(is_nothrow_move_constructible_v<_It>) { return std::move(_M_current); } constexpr iter_difference_t<_It> count() const noexcept { return _M_length; } constexpr decltype(auto) operator*() noexcept(noexcept(*_M_current)) { return *_M_current; } constexpr decltype(auto) operator*() const noexcept(noexcept(*_M_current)) requires __detail::__dereferenceable { return *_M_current; } constexpr counted_iterator& operator++() { ; ++_M_current; --_M_length; return *this; } decltype(auto) operator++(int) { ; --_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; } constexpr counted_iterator operator+(iter_difference_t<_It> __n) const requires random_access_iterator<_It> { return counted_iterator(_M_current + __n, _M_length - __n); } 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> { ; _M_current += __n; _M_length -= __n; return *this; } 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 _It2> friend constexpr iter_difference_t<_It2> operator-(const counted_iterator& __x, const counted_iterator<_It2>& __y) { return __y._M_length - __x._M_length; } friend constexpr iter_difference_t<_It> operator-(const counted_iterator& __x, default_sentinel_t) { return -__x._M_length; } 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> { ; _M_current -= __n; _M_length += __n; return *this; } constexpr decltype(auto) operator[](iter_difference_t<_It> __n) const noexcept(noexcept(_M_current[__n])) requires random_access_iterator<_It> { ; return _M_current[__n]; } template _It2> friend constexpr bool operator==(const counted_iterator& __x, const counted_iterator<_It2>& __y) { return __x._M_length == __y._M_length; } friend constexpr bool operator==(const counted_iterator& __x, default_sentinel_t) { return __x._M_length == 0; } template _It2> friend constexpr strong_ordering operator<=>(const counted_iterator& __x, const counted_iterator<_It2>& __y) { return __y._M_length <=> __x._M_length; } 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> { return ranges::iter_move(__i._M_current); } template _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))) { ranges::iter_swap(__x._M_current, __y._M_current); } private: template friend class counted_iterator; _It _M_current = _It(); iter_difference_t<_It> _M_length = 0; }; template struct incrementable_traits> { using difference_type = iter_difference_t<_It>; }; template struct iterator_traits> : iterator_traits<_It> { using pointer = void; }; template auto __niter_base(move_iterator<_Iterator> __it) -> decltype(make_move_iterator(__niter_base(__it.base()))) { return make_move_iterator(__niter_base(__it.base())); } template struct __is_move_iterator > { enum { __value = 1 }; typedef __true_type __type; }; template auto __miter_base(move_iterator<_Iterator> __it) -> decltype(__miter_base(__it.base())) { return __miter_base(__it.base()); } # 2218 "/usr/include/c++/10/bits/stl_iterator.h" 3 template using __iter_key_t = remove_const_t< typename iterator_traits<_InputIterator>::value_type::first_type>; template using __iter_val_t = typename iterator_traits<_InputIterator>::value_type::second_type; template struct pair; template using __iter_to_alloc_t = pair>, __iter_val_t<_InputIterator>>; } # 68 "/usr/include/c++/10/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/10/debug/debug.h" 1 3 # 48 "/usr/include/c++/10/debug/debug.h" 3 namespace std { namespace __debug { } } namespace __gnu_debug { using namespace std::__debug; template struct _Safe_iterator; } # 70 "/usr/include/c++/10/bits/stl_algobase.h" 2 3 # 1 "/usr/include/c++/10/bits/predefined_ops.h" 1 3 # 33 "/usr/include/c++/10/bits/predefined_ops.h" 3 namespace __gnu_cxx { namespace __ops { struct _Iter_less_iter { template constexpr bool operator()(_Iterator1 __it1, _Iterator2 __it2) const { return *__it1 < *__it2; } }; constexpr inline _Iter_less_iter __iter_less_iter() { return _Iter_less_iter(); } struct _Iter_less_val { constexpr _Iter_less_val() = default; constexpr explicit _Iter_less_val(_Iter_less_iter) { } template 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 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 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 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 struct _Iter_comp_iter { _Compare _M_comp; explicit constexpr _Iter_comp_iter(_Compare __comp) : _M_comp(std::move(__comp)) { } template constexpr bool operator()(_Iterator1 __it1, _Iterator2 __it2) { return bool(_M_comp(*__it1, *__it2)); } }; template constexpr inline _Iter_comp_iter<_Compare> __iter_comp_iter(_Compare __comp) { return _Iter_comp_iter<_Compare>(std::move(__comp)); } template struct _Iter_comp_val { _Compare _M_comp; 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 constexpr bool operator()(_Iterator __it, _Value& __val) { return bool(_M_comp(*__it, __val)); } }; template constexpr inline _Iter_comp_val<_Compare> __iter_comp_val(_Compare __comp) { return _Iter_comp_val<_Compare>(std::move(__comp)); } template constexpr inline _Iter_comp_val<_Compare> __iter_comp_val(_Iter_comp_iter<_Compare> __comp) { return _Iter_comp_val<_Compare>(std::move(__comp)); } template struct _Val_comp_iter { _Compare _M_comp; 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 constexpr bool operator()(_Value& __val, _Iterator __it) { return bool(_M_comp(__val, *__it)); } }; template constexpr inline _Val_comp_iter<_Compare> __val_comp_iter(_Compare __comp) { return _Val_comp_iter<_Compare>(std::move(__comp)); } template constexpr inline _Val_comp_iter<_Compare> __val_comp_iter(_Iter_comp_iter<_Compare> __comp) { return _Val_comp_iter<_Compare>(std::move(__comp)); } template struct _Iter_equals_val { _Value& _M_value; constexpr explicit _Iter_equals_val(_Value& __value) : _M_value(__value) { } template constexpr bool operator()(_Iterator __it) { return *__it == _M_value; } }; template constexpr inline _Iter_equals_val<_Value> __iter_equals_val(_Value& __val) { return _Iter_equals_val<_Value>(__val); } template struct _Iter_equals_iter { _Iterator1 _M_it1; constexpr explicit _Iter_equals_iter(_Iterator1 __it1) : _M_it1(__it1) { } template constexpr bool operator()(_Iterator2 __it2) { return *__it2 == *_M_it1; } }; template constexpr inline _Iter_equals_iter<_Iterator> __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) { return _Iter_equals_iter<_Iterator>(__it); } template struct _Iter_pred { _Predicate _M_pred; constexpr explicit _Iter_pred(_Predicate __pred) : _M_pred(std::move(__pred)) { } template constexpr bool operator()(_Iterator __it) { return bool(_M_pred(*__it)); } }; template constexpr inline _Iter_pred<_Predicate> __pred_iter(_Predicate __pred) { return _Iter_pred<_Predicate>(std::move(__pred)); } template struct _Iter_comp_to_val { _Compare _M_comp; _Value& _M_value; constexpr _Iter_comp_to_val(_Compare __comp, _Value& __value) : _M_comp(std::move(__comp)), _M_value(__value) { } template constexpr bool operator()(_Iterator __it) { return bool(_M_comp(*__it, _M_value)); } }; template _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 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 constexpr bool operator()(_Iterator2 __it2) { return bool(_M_comp(*__it2, *_M_it1)); } }; template 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 struct _Iter_negate { _Predicate _M_pred; constexpr explicit _Iter_negate(_Predicate __pred) : _M_pred(std::move(__pred)) { } template constexpr bool operator()(_Iterator __it) { return !bool(_M_pred(*__it)); } }; template constexpr inline _Iter_negate<_Predicate> __negate(_Iter_pred<_Predicate> __pred) { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } } } # 72 "/usr/include/c++/10/bits/stl_algobase.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template constexpr inline int __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) { static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); 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); } # 149 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) { # 182 "/usr/include/c++/10/bits/stl_algobase.h" 3 swap(*__a, *__b); } # 198 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr _ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { ; for (; __first1 != __last1; ++__first1, (void)++__first2) std::iter_swap(__first1, __first2); return __first2; } # 227 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline const _Tp& min(const _Tp& __a, const _Tp& __b) { if (__b < __a) return __b; return __a; } # 251 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline const _Tp& max(const _Tp& __a, const _Tp& __b) { if (__a < __b) return __b; return __a; } # 275 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline const _Tp& min(const _Tp& __a, const _Tp& __b, _Compare __comp) { if (__comp(__b, __a)) return __b; return __a; } # 297 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline const _Tp& max(const _Tp& __a, const _Tp& __b, _Compare __comp) { if (__comp(__a, __b)) return __b; return __a; } template constexpr inline _Iterator __niter_base(_Iterator __it) noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) { return __it; } template constexpr inline _From __niter_wrap(_From __from, _To __res) { return __from + (__res - std::__niter_base(__from)); } template constexpr inline _Iterator __niter_wrap(const _Iterator&, _Iterator __res) { return __res; } template struct __copy_move { template constexpr static _OI __copy_m(_II __first, _II __last, _OI __result) { for (; __first != __last; ++__result, (void)++__first) *__result = *__first; return __result; } }; template struct __copy_move { template 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 { template 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<> struct __copy_move { template 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 struct __copy_move<_IsMove, true, random_access_iterator_tag> { template constexpr static _Tp* __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) { using __assignable = conditional<_IsMove, is_move_assignable<_Tp>, is_copy_assignable<_Tp>>; static_assert( __assignable::type::value, "type is not assignable" ); const ptrdiff_t _Num = __last - __first; if (_Num) __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); return __result + _Num; } }; template struct char_traits; template class istreambuf_iterator; template class ostreambuf_iterator; template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type __copy_move_a2(_CharT*, _CharT*, ostreambuf_iterator<_CharT, char_traits<_CharT> >); template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type __copy_move_a2(const _CharT*, const _CharT*, ostreambuf_iterator<_CharT, char_traits<_CharT> >); template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, _CharT*>::__type __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); template 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 struct _Deque_iterator; template _OI __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, std::_Deque_iterator<_Tp, _Ref, _Ptr>, _OI); template std::_Deque_iterator<_OTp, _OTp&, _OTp*> __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_OTp, _OTp&, _OTp*>); template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); template constexpr inline _OI __copy_move_a1(_II __first, _II __last, _OI __result) { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } template 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 _OI __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, _OI); template __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> __copy_move_a(_II, _II, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); template ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); # 557 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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); } # 590 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline _OI move(_II __first, _II __last, _OI __result) { ; return std::__copy_move_a(std::__miter_base(__first), std::__miter_base(__last), __result); } template struct __copy_move_backward { template constexpr static _BI2 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) { while (__first != __last) *--__result = *--__last; return __result; } }; template struct __copy_move_backward { template 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 { template 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 { template 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 struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> { template constexpr static _Tp* __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) { using __assignable = conditional<_IsMove, is_move_assignable<_Tp>, is_copy_assignable<_Tp>>; static_assert( __assignable::type::value, "type is not assignable" ); const ptrdiff_t _Num = __last - __first; if (_Num) __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); return __result - _Num; } }; template 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 constexpr inline _BI2 __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } template _OI __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, std::_Deque_iterator<_Tp, _Ref, _Ptr>, _OI); template std::_Deque_iterator<_OTp, _OTp&, _OTp*> __copy_move_backward_a1( std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_ITp, _IRef, _IPtr>, std::_Deque_iterator<_OTp, _OTp&, _OTp*>); template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __copy_move_backward_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); template 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 _OI __copy_move_backward_a( const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, _OI); template __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> __copy_move_backward_a(_II, _II, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); template ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> __copy_move_backward_a( const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); # 794 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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); } # 830 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline _BI2 move_backward(_BI1 __first, _BI1 __last, _BI2 __result) { ; return std::__copy_move_backward_a(std::__miter_base(__first), std::__miter_base(__last), __result); } template constexpr inline typename __gnu_cxx::__enable_if::__value, void>::__type __fill_a1(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { for (; __first != __last; ++__first) *__first = __value; } template 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 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(__tmp), __len); } template 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 void __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, const _VTp&); template constexpr inline void __fill_a(_FIte __first, _FIte __last, const _Tp& __value) { std::__fill_a1(__first, __last, __value); } template void __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, const _Tp&); # 934 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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; } # 986 "/usr/include/c++/10/bits/stl_algobase.h" 3 inline constexpr long long __size_to_integer(float __n) { return (long long)__n; } inline constexpr long long __size_to_integer(double __n) { return (long long)__n; } inline constexpr long long __size_to_integer(long double __n) { return (long long)__n; } template constexpr inline typename __gnu_cxx::__enable_if::__value, _OutputIterator>::__type __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) { for (; __n > 0; --__n, (void) ++__first) *__first = __value; return __first; } template 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 ::__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 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 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 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; } # 1086 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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 struct __equal { template 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 { template 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 __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, bool>::__type __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, std::_Deque_iterator<_Tp, _Ref, _Ptr>, _II); template bool __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, bool>::__type __equal_aux1(_II, _II, std::_Deque_iterator<_Tp, _Ref, _Ptr>); template 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 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 bool __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, _II2); template bool __equal_aux(_II1, _II1, const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); template bool __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); template struct __lc_rai { template constexpr static _II1 __newlast1(_II1, _II1 __last1, _II2, _II2) { return __last1; } template constexpr static bool __cnd2(_II __first, _II __last) { return __first != __last; } }; template<> struct __lc_rai { template 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 static constexpr bool __cnd2(_RAI, _RAI) { return true; } }; template 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 struct __lexicographical_compare { template 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<> struct __lexicographical_compare { template constexpr static bool __lc(const _Tp* __first1, const _Tp* __last1, const _Up* __first2, const _Up* __last2) { const size_t __len1 = __last1 - __first1; const size_t __len2 = __last2 - __first2; if (const size_t __len = std::min(__len1, __len2)) if (int __result = std::__memcmp(__first1, __first2, __len)) return __result < 0; return __len1 < __len2; } }; template constexpr inline bool __lexicographical_compare_aux(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { typedef typename iterator_traits<_II1>::value_type _ValueType1; typedef typename iterator_traits<_II2>::value_type _ValueType2; const bool __simple = (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value && __is_pointer<_II1>::__value && __is_pointer<_II2>::__value && !is_volatile_v>> && !is_volatile_v>> ); return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, __first2, __last2); } template 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; } # 1345 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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()); } inline constexpr int __lg(int __n) { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } inline constexpr unsigned __lg(unsigned __n) { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); } inline constexpr long __lg(long __n) { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } inline constexpr unsigned long __lg(unsigned long __n) { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); } inline constexpr long long __lg(long long __n) { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } inline constexpr unsigned long long __lg(unsigned long long __n) { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); } # 1401 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline bool equal(_II1 __first1, _II1 __last1, _II2 __first2) { ; return std::__equal_aux(__first1, __last1, __first2); } # 1432 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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 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<_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 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<_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; } # 1522 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline bool equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { ; ; return std::__equal4(__first1, __last1, __first2, __last2); } # 1555 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline bool equal(_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) { ; ; return std::__equal4(__first1, __last1, __first2, __last2, __binary_pred); } # 1587 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { ; ; return std::__lexicographical_compare_aux(std::__niter_base(__first1), std::__niter_base(__last1), std::__niter_base(__first2), std::__niter_base(__last2)); } # 1624 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr inline bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp) { ; ; return std::__lexicographical_compare_impl (__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template concept __is_byte_iter = contiguous_iterator<_Iter> && __is_memcmp_ordered>::__value; template constexpr auto __min_cmp(_Tp __x, _Tp __y) { struct _Res { _Tp _M_min; decltype(__x <=> __y) _M_cmp; }; auto __c = __x <=> __y; if (__c > 0) return _Res{__y, __c}; return _Res{__x, __c}; } # 1675 "/usr/include/c++/10/bits/stl_algobase.h" 3 template constexpr auto lexicographical_compare_three_way(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _Comp __comp) -> decltype(__comp(*__first1, *__first2)) { ; ; using _Cat = decltype(__comp(*__first1, *__first2)); static_assert(same_as, _Cat>); if (!std::is_constant_evaluated()) if constexpr (same_as<_Comp, __detail::_Synth3way> || same_as<_Comp, compare_three_way>) if constexpr (__is_byte_iter<_InputIter1>) if constexpr (__is_byte_iter<_InputIter2>) { const auto [__len, __lencmp] = std::__min_cmp(__last1 - __first1, __last2 - __first2); if (__len) { const auto __c = __builtin_memcmp(&*__first1, &*__first2, __len) <=> 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 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 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); } # 1765 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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()); } # 1799 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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 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); } # 1848 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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()); } # 1884 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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 constexpr inline _InputIterator __find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred, input_iterator_tag) { while (__first != __last && !__pred(__first)) ++__first; return __first; } template 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; 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 constexpr inline _Iterator __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) { return __find_if(__first, __last, __pred, std::__iterator_category(__first)); } template 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 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; } # 2041 "/usr/include/c++/10/bits/stl_algobase.h" 3 template 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()); } } # 40 "/usr/include/c++/10/bits/char_traits.h" 2 3 # 1 "/usr/include/c++/10/bits/postypes.h" 1 3 # 38 "/usr/include/c++/10/bits/postypes.h" 3 # 39 "/usr/include/c++/10/bits/postypes.h" 3 # 1 "/usr/include/c++/10/cwchar" 1 3 # 39 "/usr/include/c++/10/cwchar" 3 # 40 "/usr/include/c++/10/cwchar" 3 # 1 "/usr/include/wchar.h" 1 3 4 # 27 "/usr/include/wchar.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 28 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4 # 75 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__))); # 87 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 typedef __float128 _Float128; # 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4 # 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4 # 214 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 typedef float _Float32; # 251 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 typedef double _Float64; # 268 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 typedef double _Float32x; # 285 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4 typedef long double _Float64x; # 121 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4 # 31 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 36 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 1 3 4 # 40 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 3 4 typedef __builtin_va_list __gnuc_va_list; # 39 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4 # 41 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 1 3 4 # 20 "/usr/include/x86_64-linux-gnu/bits/types/wint_t.h" 3 4 typedef unsigned int wint_t; # 42 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h" 1 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4 # 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4 typedef struct { int __count; union { unsigned int __wch; char __wchb[4]; } __value; } __mbstate_t; # 5 "/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h" 2 3 4 typedef __mbstate_t mbstate_t; # 43 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4 struct _IO_FILE; typedef struct _IO_FILE __FILE; # 44 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4 struct _IO_FILE; typedef struct _IO_FILE FILE; # 47 "/usr/include/wchar.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4 # 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4 # 28 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4 struct __locale_struct { struct __locale_data *__locales[13]; const unsigned short int *__ctype_b; const int *__ctype_tolower; const int *__ctype_toupper; const char *__names[13]; }; typedef struct __locale_struct *__locale_t; # 23 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 2 3 4 typedef __locale_t locale_t; # 50 "/usr/include/wchar.h" 2 3 4 # 79 "/usr/include/wchar.h" 3 4 extern "C" { struct tm; extern wchar_t *wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __attribute__ ((__nonnull__ (1, 2))); extern wchar_t *wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern wchar_t *wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () __attribute__ ((__nonnull__ (1, 2))); extern wchar_t *wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw (); extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) throw (); extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, locale_t __loc) throw (); extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, size_t __n, locale_t __loc) throw (); extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw (); extern size_t wcsxfrm (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw (); extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, locale_t __loc) throw (); extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, size_t __n, locale_t __loc) throw (); extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__)); extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc) throw () __asm ("wcschr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) throw () __asm ("wcschr") __attribute__ ((__pure__)); extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc) throw () __asm ("wcsrchr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) throw () __asm ("wcsrchr") __attribute__ ((__pure__)); # 181 "/usr/include/wchar.h" 3 4 extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) throw () __attribute__ ((__pure__)); extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) throw () __attribute__ ((__pure__)); extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) throw () __attribute__ ((__pure__)); extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept) throw () __asm ("wcspbrk") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) throw () __asm ("wcspbrk") __attribute__ ((__pure__)); extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle) throw () __asm ("wcsstr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) throw () __asm ("wcsstr") __attribute__ ((__pure__)); extern wchar_t *wcstok (wchar_t *__restrict __s, const wchar_t *__restrict __delim, wchar_t **__restrict __ptr) throw (); extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__)); extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle) throw () __asm ("wcswcs") __attribute__ ((__pure__)); extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) throw () __asm ("wcswcs") __attribute__ ((__pure__)); # 240 "/usr/include/wchar.h" 3 4 extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) throw () __attribute__ ((__pure__)); extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm ("wmemchr") __attribute__ ((__pure__)); extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) throw () __asm ("wmemchr") __attribute__ ((__pure__)); extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) throw () __attribute__ ((__pure__)); extern wchar_t *wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw (); extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw (); extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw (); extern wchar_t *wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw (); extern wint_t btowc (int __c) throw (); extern int wctob (wint_t __c) throw (); extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__)); extern size_t mbrtowc (wchar_t *__restrict __pwc, const char *__restrict __s, size_t __n, mbstate_t *__restrict __p) throw (); extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, mbstate_t *__restrict __ps) throw (); extern size_t __mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw (); extern size_t mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw (); # 337 "/usr/include/wchar.h" 3 4 extern size_t mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw (); extern size_t wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw (); extern size_t mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw (); extern size_t wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw (); extern int wcwidth (wchar_t __c) throw (); extern int wcswidth (const wchar_t *__s, size_t __n) throw (); extern double wcstod (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); extern float wcstof (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); extern long double wcstold (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); # 396 "/usr/include/wchar.h" 3 4 extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); extern _Float128 wcstof128 (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); # 428 "/usr/include/wchar.h" 3 4 extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw (); extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw (); __extension__ extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw (); __extension__ extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw (); __extension__ extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw (); __extension__ extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw (); extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) throw (); extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) throw (); __extension__ extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) throw (); __extension__ extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) throw (); extern double wcstod_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); extern float wcstof_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); extern long double wcstold_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); # 511 "/usr/include/wchar.h" 3 4 extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, locale_t __loc) throw (); # 551 "/usr/include/wchar.h" 3 4 extern wchar_t *wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw (); extern wchar_t *wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw (); # 567 "/usr/include/wchar.h" 3 4 extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw (); extern int fwide (__FILE *__fp, int __mode) throw (); extern int fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) ; extern int wprintf (const wchar_t *__restrict __format, ...) ; extern int swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __format, ...) throw () ; extern int vfwprintf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vwprintf (const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () ; extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) ; extern int wscanf (const wchar_t *__restrict __format, ...) ; extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) throw () ; extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_fwscanf") ; extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_wscanf") ; extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) throw () __asm__ ("" "__isoc99_swscanf") ; # 671 "/usr/include/wchar.h" 3 4 extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) ; extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () ; extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf") ; extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vwscanf") ; extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vswscanf") ; # 726 "/usr/include/wchar.h" 3 4 extern wint_t fgetwc (__FILE *__stream); extern wint_t getwc (__FILE *__stream); extern wint_t getwchar (void); extern wint_t fputwc (wchar_t __wc, __FILE *__stream); extern wint_t putwc (wchar_t __wc, __FILE *__stream); extern wint_t putwchar (wchar_t __wc); extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, __FILE *__restrict __stream); extern int fputws (const wchar_t *__restrict __ws, __FILE *__restrict __stream); extern wint_t ungetwc (wint_t __wc, __FILE *__stream); # 781 "/usr/include/wchar.h" 3 4 extern wint_t getwc_unlocked (__FILE *__stream); extern wint_t getwchar_unlocked (void); extern wint_t fgetwc_unlocked (__FILE *__stream); extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); # 807 "/usr/include/wchar.h" 3 4 extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); extern wint_t putwchar_unlocked (wchar_t __wc); # 817 "/usr/include/wchar.h" 3 4 extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, __FILE *__restrict __stream); extern int fputws_unlocked (const wchar_t *__restrict __ws, __FILE *__restrict __stream); extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, const wchar_t *__restrict __format, const struct tm *__restrict __tp) throw (); extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, const wchar_t *__restrict __format, const struct tm *__restrict __tp, locale_t __loc) throw (); # 856 "/usr/include/wchar.h" 3 4 } # 45 "/usr/include/c++/10/cwchar" 2 3 # 62 "/usr/include/c++/10/cwchar" 3 namespace std { using ::mbstate_t; } # 135 "/usr/include/c++/10/cwchar" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::wint_t; using ::btowc; using ::fgetwc; using ::fgetws; using ::fputwc; using ::fputws; using ::fwide; using ::fwprintf; using ::fwscanf; using ::getwc; using ::getwchar; using ::mbrlen; using ::mbrtowc; using ::mbsinit; using ::mbsrtowcs; using ::putwc; using ::putwchar; using ::swprintf; using ::swscanf; using ::ungetwc; using ::vfwprintf; using ::vfwscanf; using ::vswprintf; using ::vswscanf; using ::vwprintf; using ::vwscanf; using ::wcrtomb; using ::wcscat; using ::wcscmp; using ::wcscoll; using ::wcscpy; using ::wcscspn; using ::wcsftime; using ::wcslen; using ::wcsncat; using ::wcsncmp; using ::wcsncpy; using ::wcsrtombs; using ::wcsspn; using ::wcstod; using ::wcstof; using ::wcstok; using ::wcstol; using ::wcstoul; using ::wcsxfrm; using ::wctob; using ::wmemcmp; using ::wmemcpy; using ::wmemmove; using ::wmemset; using ::wprintf; using ::wscanf; using ::wcschr; using ::wcspbrk; using ::wcsrchr; using ::wcsstr; using ::wmemchr; # 234 "/usr/include/c++/10/cwchar" 3 } } namespace __gnu_cxx { using ::wcstold; # 260 "/usr/include/c++/10/cwchar" 3 using ::wcstoll; using ::wcstoull; } namespace std { using ::__gnu_cxx::wcstold; using ::__gnu_cxx::wcstoll; using ::__gnu_cxx::wcstoull; } # 280 "/usr/include/c++/10/cwchar" 3 namespace std { using std::wcstof; using std::vfwscanf; using std::vswscanf; using std::vwscanf; using std::wcstold; using std::wcstoll; using std::wcstoull; } # 41 "/usr/include/c++/10/bits/postypes.h" 2 3 # 68 "/usr/include/c++/10/bits/postypes.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 88 "/usr/include/c++/10/bits/postypes.h" 3 typedef long streamoff; # 98 "/usr/include/c++/10/bits/postypes.h" 3 typedef ptrdiff_t streamsize; # 111 "/usr/include/c++/10/bits/postypes.h" 3 template class fpos { private: streamoff _M_off; _StateT _M_state; public: fpos() : _M_off(0), _M_state() { } # 133 "/usr/include/c++/10/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 inline bool operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) { return streamoff(__lhs) == streamoff(__rhs); } template inline bool operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) { return streamoff(__lhs) != streamoff(__rhs); } typedef fpos streampos; typedef fpos wstreampos; typedef fpos u8streampos; typedef fpos u16streampos; typedef fpos u32streampos; } # 41 "/usr/include/c++/10/bits/char_traits.h" 2 3 # 1 "/usr/include/c++/10/cwchar" 1 3 # 39 "/usr/include/c++/10/cwchar" 3 # 40 "/usr/include/c++/10/cwchar" 3 # 42 "/usr/include/c++/10/bits/char_traits.h" 2 3 # 50 "/usr/include/c++/10/bits/char_traits.h" 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 64 "/usr/include/c++/10/bits/char_traits.h" 3 template struct _Char_types { typedef unsigned long int_type; typedef std::streampos pos_type; typedef std::streamoff off_type; typedef std::mbstate_t state_type; }; # 89 "/usr/include/c++/10/bits/char_traits.h" 3 template 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 void assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) { return __c1 < __c2; } static constexpr int compare(const char_type* __s1, const char_type* __s2, std::size_t __n); static constexpr std::size_t length(const char_type* __s); static constexpr const char_type* find(const char_type* __s, std::size_t __n, const char_type& __a); static constexpr char_type* move(char_type* __s1, const char_type* __s2, std::size_t __n); static constexpr char_type* copy(char_type* __s1, const char_type* __s2, std::size_t __n); static constexpr char_type* assign(char_type* __s, std::size_t __n, char_type __a); static constexpr char_type to_char_type(const int_type& __c) { return static_cast(__c); } static constexpr int_type to_int_type(const char_type& __c) { return static_cast(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } static constexpr int_type eof() { return static_cast(-1); } static constexpr int_type not_eof(const int_type& __c) { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } }; template 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 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 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 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 (__s1 > __s2 && __s1 < __s2 + __n) std::copy_backward(__s2, __s2 + __n, __s1 + __n); else std::copy(__s2, __s2 + __n, __s1); return __s1; } return static_cast<_CharT*>(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))); } template constexpr typename char_traits<_CharT>::char_type* char_traits<_CharT>:: copy(char_type* __s1, const char_type* __s2, std::size_t __n) { std::copy(__s2, __s2 + __n, __s1); return __s1; } template constexpr typename char_traits<_CharT>::char_type* char_traits<_CharT>:: assign(char_type* __s, std::size_t __n, char_type __a) { std::fill_n(__s, __n, __a); return __s; } } namespace std __attribute__ ((__visibility__ ("default"))) { # 255 "/usr/include/c++/10/bits/char_traits.h" 3 template static inline __attribute__((__always_inline__)) constexpr bool __constant_string_p(const _CharT* __s) { (void) __s; return __builtin_is_constant_evaluated(); } # 278 "/usr/include/c++/10/bits/char_traits.h" 3 template static inline __attribute__((__always_inline__)) constexpr bool __constant_char_array_p(const _CharT* __a, size_t __n) { (void) __a; (void) __n; return __builtin_is_constant_evaluated(); } # 309 "/usr/include/c++/10/bits/char_traits.h" 3 template struct char_traits : public __gnu_cxx::char_traits<_CharT> { }; template<> struct char_traits { 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 { __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(__c1) < static_cast(__c2)); } static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return 0; if (__builtin_constant_p(__n) && __constant_char_array_p(__s1, __n) && __constant_char_array_p(__s2, __n)) { 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 (__constant_string_p(__s)) return __gnu_cxx::char_traits::length(__s); return __builtin_strlen(__s); } static constexpr const char_type* find(const char_type* __s, size_t __n, const char_type& __a) { if (__n == 0) return 0; if (__builtin_constant_p(__n) && __builtin_constant_p(__a) && __constant_char_array_p(__s, __n)) return __gnu_cxx::char_traits::find(__s, __n, __a); return static_cast(__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::move(__s1, __s2, __n); return static_cast(__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::copy(__s1, __s2, __n); return static_cast(__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::assign(__s, __n, __a); return static_cast(__builtin_memset(__s, __a, __n)); } static constexpr char_type to_char_type(const int_type& __c) noexcept { return static_cast(__c); } static constexpr int_type to_int_type(const char_type& __c) noexcept { return static_cast(static_cast(__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(-1); } static constexpr int_type not_eof(const int_type& __c) noexcept { return (__c == eof()) ? 0 : __c; } }; template<> struct char_traits { 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 { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) noexcept { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) noexcept { return __c1 < __c2; } static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return 0; if (__builtin_constant_p(__n) && __constant_char_array_p(__s1, __n) && __constant_char_array_p(__s2, __n)) return __gnu_cxx::char_traits::compare(__s1, __s2, __n); return wmemcmp(__s1, __s2, __n); } static constexpr size_t length(const char_type* __s) { if (__constant_string_p(__s)) return __gnu_cxx::char_traits::length(__s); return wcslen(__s); } static constexpr const char_type* find(const char_type* __s, size_t __n, const char_type& __a) { if (__n == 0) return 0; if (__builtin_constant_p(__n) && __builtin_constant_p(__a) && __constant_char_array_p(__s, __n)) return __gnu_cxx::char_traits::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::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::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; if (std::is_constant_evaluated()) return __gnu_cxx::char_traits::assign(__s, __n, __a); return wmemset(__s, __a, __n); } static constexpr char_type to_char_type(const int_type& __c) noexcept { return char_type(__c); } static constexpr int_type to_int_type(const char_type& __c) noexcept { return int_type(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) noexcept { return __c1 == __c2; } static constexpr int_type eof() noexcept { return static_cast((0xffffffffu)); } static constexpr int_type not_eof(const int_type& __c) noexcept { return eq_int_type(__c, eof()) ? 0 : __c; } }; template<> struct char_traits { typedef char8_t char_type; typedef unsigned int int_type; typedef u8streampos 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 { __c1 = __c2; } static constexpr bool eq(const char_type& __c1, const char_type& __c2) noexcept { return __c1 == __c2; } static constexpr bool lt(const char_type& __c1, const char_type& __c2) noexcept { return __c1 < __c2; } static constexpr int compare(const char_type* __s1, const char_type* __s2, size_t __n) { if (__n == 0) return 0; if (__builtin_constant_p(__n) && __constant_char_array_p(__s1, __n) && __constant_char_array_p(__s2, __n)) return __gnu_cxx::char_traits::compare(__s1, __s2, __n); return __builtin_memcmp(__s1, __s2, __n); } static constexpr size_t length(const char_type* __s) { if (__constant_string_p(__s)) return __gnu_cxx::char_traits::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 (__builtin_constant_p(__n) && __builtin_constant_p(__a) && __constant_char_array_p(__s, __n)) return __gnu_cxx::char_traits::find(__s, __n, __a); return static_cast(__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::move(__s1, __s2, __n); return static_cast(__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::copy(__s1, __s2, __n); return static_cast(__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::assign(__s, __n, __a); return static_cast(__builtin_memset(__s, __a, __n)); } static constexpr char_type to_char_type(const int_type& __c) noexcept { return char_type(__c); } static constexpr int_type to_int_type(const char_type& __c) noexcept { return int_type(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) noexcept { return __c1 == __c2; } static constexpr int_type eof() noexcept { return static_cast(-1); } static constexpr int_type not_eof(const int_type& __c) noexcept { return eq_int_type(__c, eof()) ? 0 : __c; } }; } # 1 "/usr/include/c++/10/cstdint" 1 3 # 32 "/usr/include/c++/10/cstdint" 3 # 33 "/usr/include/c++/10/cstdint" 3 # 41 "/usr/include/c++/10/cstdint" 3 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 1 3 4 # 9 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 3 4 # 1 "/usr/include/stdint.h" 1 3 4 # 26 "/usr/include/stdint.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 27 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4 # 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 typedef unsigned char __u_char; typedef unsigned short int __u_short; typedef unsigned int __u_int; typedef unsigned long int __u_long; typedef signed char __int8_t; typedef unsigned char __uint8_t; typedef signed short int __int16_t; typedef unsigned short int __uint16_t; typedef signed int __int32_t; typedef unsigned int __uint32_t; typedef signed long int __int64_t; typedef unsigned long int __uint64_t; typedef __int8_t __int_least8_t; typedef __uint8_t __uint_least8_t; typedef __int16_t __int_least16_t; typedef __uint16_t __uint_least16_t; typedef __int32_t __int_least32_t; typedef __uint32_t __uint_least32_t; typedef __int64_t __int_least64_t; typedef __uint64_t __uint_least64_t; typedef long int __quad_t; typedef unsigned long int __u_quad_t; typedef long int __intmax_t; typedef unsigned long int __uintmax_t; # 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4 # 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4 # 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4 typedef unsigned long int __dev_t; typedef unsigned int __uid_t; typedef unsigned int __gid_t; typedef unsigned long int __ino_t; typedef unsigned long int __ino64_t; typedef unsigned int __mode_t; typedef unsigned long int __nlink_t; typedef long int __off_t; typedef long int __off64_t; typedef int __pid_t; typedef struct { int __val[2]; } __fsid_t; typedef long int __clock_t; typedef unsigned long int __rlim_t; typedef unsigned long int __rlim64_t; typedef unsigned int __id_t; typedef long int __time_t; typedef unsigned int __useconds_t; typedef long int __suseconds_t; typedef int __daddr_t; typedef int __key_t; typedef int __clockid_t; typedef void * __timer_t; typedef long int __blksize_t; typedef long int __blkcnt_t; typedef long int __blkcnt64_t; typedef unsigned long int __fsblkcnt_t; typedef unsigned long int __fsblkcnt64_t; typedef unsigned long int __fsfilcnt_t; typedef unsigned long int __fsfilcnt64_t; typedef long int __fsword_t; typedef long int __ssize_t; typedef long int __syscall_slong_t; typedef unsigned long int __syscall_ulong_t; typedef __off64_t __loff_t; typedef char *__caddr_t; typedef long int __intptr_t; typedef unsigned int __socklen_t; typedef int __sig_atomic_t; # 28 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 30 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4 typedef __int8_t int8_t; typedef __int16_t int16_t; typedef __int32_t int32_t; typedef __int64_t int64_t; # 35 "/usr/include/stdint.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h" 3 4 typedef __uint8_t uint8_t; typedef __uint16_t uint16_t; typedef __uint32_t uint32_t; typedef __uint64_t uint64_t; # 38 "/usr/include/stdint.h" 2 3 4 typedef __int_least8_t int_least8_t; typedef __int_least16_t int_least16_t; typedef __int_least32_t int_least32_t; typedef __int_least64_t int_least64_t; typedef __uint_least8_t uint_least8_t; typedef __uint_least16_t uint_least16_t; typedef __uint_least32_t uint_least32_t; typedef __uint_least64_t uint_least64_t; typedef signed char int_fast8_t; typedef long int int_fast16_t; typedef long int int_fast32_t; typedef long int int_fast64_t; # 71 "/usr/include/stdint.h" 3 4 typedef unsigned char uint_fast8_t; typedef unsigned long int uint_fast16_t; typedef unsigned long int uint_fast32_t; typedef unsigned long int uint_fast64_t; # 87 "/usr/include/stdint.h" 3 4 typedef long int intptr_t; typedef unsigned long int uintptr_t; # 101 "/usr/include/stdint.h" 3 4 typedef __intmax_t intmax_t; typedef __uintmax_t uintmax_t; # 10 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdint.h" 2 3 4 # 42 "/usr/include/c++/10/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; } # 700 "/usr/include/c++/10/bits/char_traits.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template<> struct char_traits { typedef char16_t char_type; typedef uint_least16_t 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 { __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::move(__s1, __s2, __n); return (static_cast (__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::copy(__s1, __s2, __n); return (static_cast (__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 __c == eof() ? int_type(0xfffd) : int_type(__c); } static constexpr bool eq_int_type(const int_type& __c1, const int_type& __c2) noexcept { return __c1 == __c2; } static constexpr int_type eof() noexcept { return static_cast(-1); } static constexpr int_type not_eof(const int_type& __c) noexcept { return eq_int_type(__c, eof()) ? 0 : __c; } }; template<> struct char_traits { typedef char32_t char_type; typedef uint_least32_t 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 { __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::move(__s1, __s2, __n); return (static_cast (__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::copy(__s1, __s2, __n); return (static_cast (__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(-1); } static constexpr int_type not_eof(const int_type& __c) noexcept { return eq_int_type(__c, eof()) ? 0 : __c; } }; namespace __detail { template 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> ); return static_cast<_Cat>(__cmp <=> 0); } else return static_cast(__cmp <=> 0); } } } # 41 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/allocator.h" 1 3 # 46 "/usr/include/c++/10/bits/allocator.h" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++allocator.h" 1 3 # 33 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++allocator.h" 3 # 1 "/usr/include/c++/10/ext/new_allocator.h" 1 3 # 40 "/usr/include/c++/10/ext/new_allocator.h" 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { # 54 "/usr/include/c++/10/ext/new_allocator.h" 3 template class new_allocator { public: typedef _Tp value_type; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; # 75 "/usr/include/c++/10/ext/new_allocator.h" 3 typedef std::true_type propagate_on_container_move_assignment; constexpr new_allocator() noexcept { } constexpr new_allocator(const new_allocator&) noexcept { } template constexpr new_allocator(const new_allocator<_Tp1>&) noexcept { } # 102 "/usr/include/c++/10/ext/new_allocator.h" 3 [[__nodiscard__]] _Tp* allocate(size_type __n, const void* = static_cast(0)) { if (__n > this->_M_max_size()) std::__throw_bad_alloc(); if (alignof(_Tp) > 16) { std::align_val_t __al = std::align_val_t(alignof(_Tp)); return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al)); } return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); } void deallocate(_Tp* __p, size_type __t) { if (alignof(_Tp) > 16) { ::operator delete(__p, __t * sizeof(_Tp), std::align_val_t(alignof(_Tp))); return; } ::operator delete(__p , __t * sizeof(_Tp) ); } # 169 "/usr/include/c++/10/ext/new_allocator.h" 3 template friend constexpr bool operator==(const new_allocator&, const new_allocator<_Up>&) noexcept { return true; } # 183 "/usr/include/c++/10/ext/new_allocator.h" 3 private: constexpr size_type _M_max_size() const noexcept { return std::size_t(0x7fffffffffffffffL) / sizeof(_Tp); } }; } # 34 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++allocator.h" 2 3 namespace std { # 47 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++allocator.h" 3 template using __allocator_base = __gnu_cxx::new_allocator<_Tp>; } # 47 "/usr/include/c++/10/bits/allocator.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template<> class allocator { public: typedef void value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; # 79 "/usr/include/c++/10/bits/allocator.h" 3 allocator() = default; template constexpr allocator(const allocator<_Up>&) { } # 105 "/usr/include/c++/10/bits/allocator.h" 3 }; # 115 "/usr/include/c++/10/bits/allocator.h" 3 template class allocator : public __allocator_base<_Tp> { public: typedef _Tp value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; # 136 "/usr/include/c++/10/bits/allocator.h" 3 typedef true_type propagate_on_container_move_assignment; typedef true_type is_always_equal; constexpr allocator() noexcept { } constexpr allocator(const allocator& __a) noexcept : __allocator_base<_Tp>(__a) { } allocator& operator=(const allocator&) = default; template constexpr allocator(const allocator<_Tp1>&) noexcept { } constexpr ~allocator() noexcept { } [[nodiscard,__gnu__::__always_inline__]] constexpr _Tp* allocate(size_t __n) { if (std::is_constant_evaluated()) return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); 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 constexpr bool operator==(const allocator&, const allocator&) noexcept { return true; } # 202 "/usr/include/c++/10/bits/allocator.h" 3 }; template inline constexpr bool operator==(const allocator<_T1>&, const allocator<_T2>&) noexcept { return true; } # 220 "/usr/include/c++/10/bits/allocator.h" 3 template class allocator { public: typedef _Tp value_type; template allocator(const allocator<_Up>&) { } }; template class allocator { public: typedef _Tp value_type; template allocator(const allocator<_Up>&) { } }; template class allocator { public: typedef _Tp value_type; template allocator(const allocator<_Up>&) { } }; extern template class allocator; extern template class allocator; template struct __alloc_swap { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; template struct __alloc_swap<_Alloc, false> { static void _S_do_it(_Alloc& __one, _Alloc& __two) noexcept { if (__one != __two) swap(__one, __two); } }; template struct __alloc_neq { static bool _S_do_it(const _Alloc&, const _Alloc&) { return false; } }; template struct __alloc_neq<_Alloc, false> { static bool _S_do_it(const _Alloc& __one, const _Alloc& __two) { return __one != __two; } }; template, is_nothrow_move_constructible>::value> struct __shrink_to_fit_aux { static bool _S_do_it(_Tp&) noexcept { return false; } }; template struct __shrink_to_fit_aux<_Tp, true> { static bool _S_do_it(_Tp& __c) noexcept { try { _Tp(__make_move_if_noexcept_iterator(__c.begin()), __make_move_if_noexcept_iterator(__c.end()), __c.get_allocator()).swap(__c); return true; } catch(...) { return false; } } }; } # 42 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/localefwd.h" 1 3 # 37 "/usr/include/c++/10/bits/localefwd.h" 3 # 38 "/usr/include/c++/10/bits/localefwd.h" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++locale.h" 1 3 # 39 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++locale.h" 3 # 40 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++locale.h" 3 # 1 "/usr/include/c++/10/clocale" 1 3 # 39 "/usr/include/c++/10/clocale" 3 # 40 "/usr/include/c++/10/clocale" 3 # 1 "/usr/include/locale.h" 1 3 4 # 28 "/usr/include/locale.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 29 "/usr/include/locale.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/locale.h" 1 3 4 # 30 "/usr/include/locale.h" 2 3 4 extern "C" { # 51 "/usr/include/locale.h" 3 4 struct lconv { char *decimal_point; char *thousands_sep; char *grouping; char *int_curr_symbol; char *currency_symbol; char *mon_decimal_point; char *mon_thousands_sep; char *mon_grouping; char *positive_sign; char *negative_sign; char int_frac_digits; char frac_digits; char p_cs_precedes; char p_sep_by_space; char n_cs_precedes; char n_sep_by_space; char p_sign_posn; char n_sign_posn; char int_p_cs_precedes; char int_p_sep_by_space; char int_n_cs_precedes; char int_n_sep_by_space; char int_p_sign_posn; char int_n_sign_posn; # 118 "/usr/include/locale.h" 3 4 }; extern char *setlocale (int __category, const char *__locale) throw (); extern struct lconv *localeconv (void) throw (); # 141 "/usr/include/locale.h" 3 4 extern locale_t newlocale (int __category_mask, const char *__locale, locale_t __base) throw (); # 176 "/usr/include/locale.h" 3 4 extern locale_t duplocale (locale_t __dataset) throw (); extern void freelocale (locale_t __dataset) throw (); extern locale_t uselocale (locale_t __dataset) throw (); } # 43 "/usr/include/c++/10/clocale" 2 3 # 51 "/usr/include/c++/10/clocale" 3 namespace std { using ::lconv; using ::setlocale; using ::localeconv; } # 42 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++locale.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { extern "C" __typeof(uselocale) __uselocale; } namespace std __attribute__ ((__visibility__ ("default"))) { typedef __locale_t __c_locale; inline int __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)), char* __out, const int __size __attribute__ ((__unused__)), const char* __fmt, ...) { __c_locale __old = __gnu_cxx::__uselocale(__cloc); # 88 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++locale.h" 3 __builtin_va_list __args; __builtin_va_start(__args, __fmt); const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args); __builtin_va_end(__args); __gnu_cxx::__uselocale(__old); return __ret; } } # 41 "/usr/include/c++/10/bits/localefwd.h" 2 3 # 1 "/usr/include/c++/10/iosfwd" 1 3 # 36 "/usr/include/c++/10/iosfwd" 3 # 37 "/usr/include/c++/10/iosfwd" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 74 "/usr/include/c++/10/iosfwd" 3 class ios_base; template > class basic_ios; template > class basic_streambuf; template > class basic_istream; template > class basic_ostream; template > class basic_iostream; namespace __cxx11 { template, typename _Alloc = allocator<_CharT> > class basic_stringbuf; template, typename _Alloc = allocator<_CharT> > class basic_istringstream; template, typename _Alloc = allocator<_CharT> > class basic_ostringstream; template, typename _Alloc = allocator<_CharT> > class basic_stringstream; } template > class basic_filebuf; template > class basic_ifstream; template > class basic_ofstream; template > class basic_fstream; template > class istreambuf_iterator; template > class ostreambuf_iterator; typedef basic_ios ios; typedef basic_streambuf streambuf; typedef basic_istream istream; typedef basic_ostream ostream; typedef basic_iostream iostream; typedef basic_stringbuf stringbuf; typedef basic_istringstream istringstream; typedef basic_ostringstream ostringstream; typedef basic_stringstream stringstream; typedef basic_filebuf filebuf; typedef basic_ifstream ifstream; typedef basic_ofstream ofstream; typedef basic_fstream fstream; typedef basic_ios wios; typedef basic_streambuf wstreambuf; typedef basic_istream wistream; typedef basic_ostream wostream; typedef basic_iostream wiostream; typedef basic_stringbuf wstringbuf; typedef basic_istringstream wistringstream; typedef basic_ostringstream wostringstream; typedef basic_stringstream wstringstream; typedef basic_filebuf wfilebuf; typedef basic_ifstream wifstream; typedef basic_ofstream wofstream; typedef basic_fstream wfstream; } # 42 "/usr/include/c++/10/bits/localefwd.h" 2 3 # 1 "/usr/include/c++/10/cctype" 1 3 # 39 "/usr/include/c++/10/cctype" 3 # 40 "/usr/include/c++/10/cctype" 3 # 1 "/usr/include/ctype.h" 1 3 4 # 28 "/usr/include/ctype.h" 3 4 extern "C" { # 39 "/usr/include/ctype.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4 # 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4 # 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4 # 40 "/usr/include/ctype.h" 2 3 4 enum { _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) }; # 79 "/usr/include/ctype.h" 3 4 extern const unsigned short int **__ctype_b_loc (void) throw () __attribute__ ((__const__)); extern const __int32_t **__ctype_tolower_loc (void) throw () __attribute__ ((__const__)); extern const __int32_t **__ctype_toupper_loc (void) throw () __attribute__ ((__const__)); # 108 "/usr/include/ctype.h" 3 4 extern int isalnum (int) throw (); extern int isalpha (int) throw (); extern int iscntrl (int) throw (); extern int isdigit (int) throw (); extern int islower (int) throw (); extern int isgraph (int) throw (); extern int isprint (int) throw (); extern int ispunct (int) throw (); extern int isspace (int) throw (); extern int isupper (int) throw (); extern int isxdigit (int) throw (); extern int tolower (int __c) throw (); extern int toupper (int __c) throw (); extern int isblank (int) throw (); extern int isctype (int __c, int __mask) throw (); extern int isascii (int __c) throw (); extern int toascii (int __c) throw (); extern int _toupper (int) throw (); extern int _tolower (int) throw (); # 251 "/usr/include/ctype.h" 3 4 extern int isalnum_l (int, locale_t) throw (); extern int isalpha_l (int, locale_t) throw (); extern int iscntrl_l (int, locale_t) throw (); extern int isdigit_l (int, locale_t) throw (); extern int islower_l (int, locale_t) throw (); extern int isgraph_l (int, locale_t) throw (); extern int isprint_l (int, locale_t) throw (); extern int ispunct_l (int, locale_t) throw (); extern int isspace_l (int, locale_t) throw (); extern int isupper_l (int, locale_t) throw (); extern int isxdigit_l (int, locale_t) throw (); extern int isblank_l (int, locale_t) throw (); extern int __tolower_l (int __c, locale_t __l) throw (); extern int tolower_l (int __c, locale_t __l) throw (); extern int __toupper_l (int __c, locale_t __l) throw (); extern int toupper_l (int __c, locale_t __l) throw (); # 327 "/usr/include/ctype.h" 3 4 } # 43 "/usr/include/c++/10/cctype" 2 3 # 62 "/usr/include/c++/10/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 "/usr/include/c++/10/bits/localefwd.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 55 "/usr/include/c++/10/bits/localefwd.h" 3 class locale; template bool has_facet(const locale&) throw(); template const _Facet& use_facet(const locale&); template bool isspace(_CharT, const locale&); template bool isprint(_CharT, const locale&); template bool iscntrl(_CharT, const locale&); template bool isupper(_CharT, const locale&); template bool islower(_CharT, const locale&); template bool isalpha(_CharT, const locale&); template bool isdigit(_CharT, const locale&); template bool ispunct(_CharT, const locale&); template bool isxdigit(_CharT, const locale&); template bool isalnum(_CharT, const locale&); template bool isgraph(_CharT, const locale&); template bool isblank(_CharT, const locale&); template _CharT toupper(_CharT, const locale&); template _CharT tolower(_CharT, const locale&); class ctype_base; template class ctype; template<> class ctype; template<> class ctype; template class ctype_byname; class codecvt_base; template class codecvt; template<> class codecvt; template<> class codecvt; template<> class codecvt; template<> class codecvt; template<> class codecvt; template<> class codecvt; template class codecvt_byname; template > class num_get; template > class num_put; namespace __cxx11 { template class numpunct; template class numpunct_byname; } namespace __cxx11 { template class collate; template class collate_byname; } class time_base; namespace __cxx11 { template > class time_get; template > class time_get_byname; } template > class time_put; template > class time_put_byname; class money_base; namespace __cxx11 { template > class money_get; template > class money_put; } namespace __cxx11 { template class moneypunct; template class moneypunct_byname; } class messages_base; namespace __cxx11 { template class messages; template class messages_byname; } } # 44 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/ostream_insert.h" 1 3 # 33 "/usr/include/c++/10/bits/ostream_insert.h" 3 # 34 "/usr/include/c++/10/bits/ostream_insert.h" 3 # 1 "/usr/include/c++/10/bits/cxxabi_forced.h" 1 3 # 34 "/usr/include/c++/10/bits/cxxabi_forced.h" 3 # 35 "/usr/include/c++/10/bits/cxxabi_forced.h" 3 #pragma GCC visibility push(default) namespace __cxxabiv1 { class __forced_unwind { virtual ~__forced_unwind() throw(); virtual void __pure_dummy() = 0; }; } #pragma GCC visibility pop # 37 "/usr/include/c++/10/bits/ostream_insert.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template 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 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 basic_ostream<_CharT, _Traits>& __ostream_insert(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s, streamsize __n) { typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base; typename __ostream_type::sentry __cerb(__out); if (__cerb) { try { const streamsize __w = __out.width(); if (__w > __n) { const bool __left = ((__out.flags() & __ios_base::adjustfield) == __ios_base::left); if (!__left) __ostream_fill(__out, __w - __n); if (__out.good()) __ostream_write(__out, __s, __n); if (__left && __out.good()) __ostream_fill(__out, __w - __n); } else __ostream_write(__out, __s, __n); __out.width(0); } catch(__cxxabiv1::__forced_unwind&) { __out._M_setstate(__ios_base::badbit); throw; } catch(...) { __out._M_setstate(__ios_base::badbit); } } return __out; } extern template ostream& __ostream_insert(ostream&, const char*, streamsize); extern template wostream& __ostream_insert(wostream&, const wchar_t*, streamsize); } # 45 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/stl_function.h" 1 3 # 63 "/usr/include/c++/10/bits/stl_function.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 104 "/usr/include/c++/10/bits/stl_function.h" 3 template struct unary_function { typedef _Arg argument_type; typedef _Result result_type; }; template struct binary_function { typedef _Arg1 first_argument_type; typedef _Arg2 second_argument_type; typedef _Result result_type; }; # 144 "/usr/include/c++/10/bits/stl_function.h" 3 struct __is_transparent; template struct plus; template struct minus; template struct multiplies; template struct divides; template struct modulus; template struct negate; template struct plus : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; } }; template struct minus : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; } }; template struct multiplies : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; } }; template struct divides : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; } }; template struct modulus : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; } }; template struct negate : public unary_function<_Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x) const { return -__x; } }; template<> struct plus { template 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 { template 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 { template 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 { template 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 { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct negate { template constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(-std::forward<_Tp>(__t))) -> decltype(-std::forward<_Tp>(__t)) { return -std::forward<_Tp>(__t); } typedef __is_transparent is_transparent; }; # 330 "/usr/include/c++/10/bits/stl_function.h" 3 template struct equal_to; template struct not_equal_to; template struct greater; template struct less; template struct greater_equal; template struct less_equal; template struct equal_to : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; } }; template struct not_equal_to : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; } }; template struct greater : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; } }; template struct less : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; } }; template struct greater_equal : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; } }; template struct less_equal : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; } }; template struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (__builtin_is_constant_evaluated()) return __x > __y; return (long unsigned int)__x > (long unsigned int)__y; } }; template struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (__builtin_is_constant_evaluated()) return __x < __y; return (long unsigned int)__x < (long unsigned int)__y; } }; template struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (__builtin_is_constant_evaluated()) return __x >= __y; return (long unsigned int)__x >= (long unsigned int)__y; } }; template struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> { constexpr bool operator()(_Tp* __x, _Tp* __y) const noexcept { if (__builtin_is_constant_evaluated()) return __x <= __y; return (long unsigned int)__x <= (long unsigned int)__y; } }; template<> struct equal_to { template 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 { template 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 { template 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 constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return greater>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return greater{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; template<> struct less { template 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 constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return less>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return less{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; template<> struct greater_equal { template 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 constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return greater_equal>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return greater_equal{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; template<> struct less_equal { template 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 constexpr bool operator()(_Tp* __t, _Up* __u) const noexcept { return less_equal>{}(__t, __u); } typedef __is_transparent is_transparent; private: template static constexpr decltype(auto) _S_cmp(_Tp&& __t, _Up&& __u, false_type) { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } template static constexpr bool _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept { return less_equal{}( static_cast(std::forward<_Tp>(__t)), static_cast(std::forward<_Up>(__u))); } template struct __not_overloaded2 : true_type { }; template struct __not_overloaded2<_Tp, _Up, __void_t< decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> : false_type { }; template struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; template struct __not_overloaded<_Tp, _Up, __void_t< decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> : false_type { }; template using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, is_convertible<_Tp, const volatile void*>, is_convertible<_Up, const volatile void*>>; }; # 774 "/usr/include/c++/10/bits/stl_function.h" 3 template struct logical_and; template struct logical_or; template struct logical_not; template struct logical_and : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; } }; template struct logical_or : public binary_function<_Tp, _Tp, bool> { constexpr bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; } }; template struct logical_not : public unary_function<_Tp, bool> { constexpr bool operator()(const _Tp& __x) const { return !__x; } }; template<> struct logical_and { template 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 { template constexpr auto operator()(_Tp&& __t, _Up&& __u) const noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } typedef __is_transparent is_transparent; }; template<> struct logical_not { template constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(!std::forward<_Tp>(__t))) -> decltype(!std::forward<_Tp>(__t)) { return !std::forward<_Tp>(__t); } typedef __is_transparent is_transparent; }; template struct bit_and; template struct bit_or; template struct bit_xor; template struct bit_not; template struct bit_and : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x & __y; } }; template struct bit_or : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x | __y; } }; template struct bit_xor : public binary_function<_Tp, _Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x ^ __y; } }; template struct bit_not : public unary_function<_Tp, _Tp> { constexpr _Tp operator()(const _Tp& __x) const { return ~__x; } }; template <> struct bit_and { template 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 { template 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 { template 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 { template constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(~std::forward<_Tp>(__t))) -> decltype(~std::forward<_Tp>(__t)) { return ~std::forward<_Tp>(__t); } typedef __is_transparent is_transparent; }; # 1002 "/usr/include/c++/10/bits/stl_function.h" 3 template class unary_negate : public unary_function { 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 constexpr inline unary_negate<_Predicate> not1(const _Predicate& __pred) { return unary_negate<_Predicate>(__pred); } template class binary_negate : public binary_function { 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 constexpr inline binary_negate<_Predicate> not2(const _Predicate& __pred) { return binary_negate<_Predicate>(__pred); } # 1079 "/usr/include/c++/10/bits/stl_function.h" 3 template class pointer_to_unary_function : public unary_function<_Arg, _Result> { protected: _Result (*_M_ptr)(_Arg); public: pointer_to_unary_function() { } explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) { } _Result operator()(_Arg __x) const { return _M_ptr(__x); } }; template inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg)) { return pointer_to_unary_function<_Arg, _Result>(__x); } template class pointer_to_binary_function : public binary_function<_Arg1, _Arg2, _Result> { protected: _Result (*_M_ptr)(_Arg1, _Arg2); public: pointer_to_binary_function() { } explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) : _M_ptr(__x) { } _Result operator()(_Arg1 __x, _Arg2 __y) const { return _M_ptr(__x, __y); } }; template inline pointer_to_binary_function<_Arg1, _Arg2, _Result> ptr_fun(_Result (*__x)(_Arg1, _Arg2)) { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } template struct _Identity : public unary_function<_Tp, _Tp> { _Tp& operator()(_Tp& __x) const { return __x; } const _Tp& operator()(const _Tp& __x) const { return __x; } }; template struct _Identity : _Identity<_Tp> { }; template 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::first_type& operator()(_Pair2& __x) const { return __x.first; } template const typename _Pair2::first_type& operator()(const _Pair2& __x) const { return __x.first; } }; template struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type> { typename _Pair::second_type& operator()(_Pair& __x) const { return __x.second; } const typename _Pair::second_type& operator()(const _Pair& __x) const { return __x.second; } }; # 1202 "/usr/include/c++/10/bits/stl_function.h" 3 template class mem_fun_t : public unary_function<_Tp*, _Ret> { public: explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) { } _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); } private: _Ret (_Tp::*_M_f)(); }; template class const_mem_fun_t : public unary_function { public: explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) { } _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); } private: _Ret (_Tp::*_M_f)() const; }; template class mem_fun_ref_t : public unary_function<_Tp, _Ret> { public: explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) { } _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); } private: _Ret (_Tp::*_M_f)(); }; template class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> { public: explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) { } _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); } private: _Ret (_Tp::*_M_f)() const; }; template class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> { public: explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) { } _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg); }; template class const_mem_fun1_t : public binary_function { public: explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) { } _Ret operator()(const _Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg) const; }; template class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { public: explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) { } _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg); }; template class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { public: explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) { } _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); } private: _Ret (_Tp::*_M_f)(_Arg) const; }; template inline mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)()) { return mem_fun_t<_Ret, _Tp>(__f); } template inline const_mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)() const) { return const_mem_fun_t<_Ret, _Tp>(__f); } template inline mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)()) { return mem_fun_ref_t<_Ret, _Tp>(__f); } template 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 inline mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } template 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 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 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } } # 1 "/usr/include/c++/10/backward/binders.h" 1 3 # 60 "/usr/include/c++/10/backward/binders.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" namespace std __attribute__ ((__visibility__ ("default"))) { # 107 "/usr/include/c++/10/backward/binders.h" 3 template class binder1st : public unary_function { protected: _Operation op; typename _Operation::first_argument_type value; public: binder1st(const _Operation& __x, const typename _Operation::first_argument_type& __y) : op(__x), value(__y) { } typename _Operation::result_type operator()(const typename _Operation::second_argument_type& __x) const { return op(value, __x); } typename _Operation::result_type operator()(typename _Operation::second_argument_type& __x) const { return op(value, __x); } } __attribute__ ((__deprecated__)); template 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 class binder2nd : public unary_function { protected: _Operation op; typename _Operation::second_argument_type value; public: binder2nd(const _Operation& __x, const typename _Operation::second_argument_type& __y) : op(__x), value(__y) { } typename _Operation::result_type operator()(const typename _Operation::first_argument_type& __x) const { return op(__x, value); } typename _Operation::result_type operator()(typename _Operation::first_argument_type& __x) const { return op(__x, value); } } __attribute__ ((__deprecated__)); template inline binder2nd<_Operation> bind2nd(const _Operation& __fn, const _Tp& __x) { typedef typename _Operation::second_argument_type _Arg2_type; return binder2nd<_Operation>(__fn, _Arg2_type(__x)); } } #pragma GCC diagnostic pop # 1393 "/usr/include/c++/10/bits/stl_function.h" 2 3 # 49 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/stl_algo.h" 1 3 # 59 "/usr/include/c++/10/bits/stl_algo.h" 3 # 1 "/usr/include/c++/10/cstdlib" 1 3 # 39 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/cstdlib" 3 # 75 "/usr/include/c++/10/cstdlib" 3 # 1 "/usr/include/stdlib.h" 1 3 4 # 25 "/usr/include/stdlib.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 26 "/usr/include/stdlib.h" 2 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 32 "/usr/include/stdlib.h" 2 3 4 extern "C" { # 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4 # 52 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4 typedef enum { P_ALL, P_PID, P_PGID } idtype_t; # 40 "/usr/include/stdlib.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4 # 41 "/usr/include/stdlib.h" 2 3 4 # 58 "/usr/include/stdlib.h" 3 4 typedef struct { int quot; int rem; } div_t; typedef struct { long int quot; long int rem; } ldiv_t; __extension__ typedef struct { long long int quot; long long int rem; } lldiv_t; # 97 "/usr/include/stdlib.h" 3 4 extern size_t __ctype_get_mb_cur_max (void) throw () ; extern double atof (const char *__nptr) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; extern int atoi (const char *__nptr) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; extern long int atol (const char *__nptr) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; __extension__ extern long long int atoll (const char *__nptr) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; extern double strtod (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); extern float strtof (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); extern long double strtold (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); # 140 "/usr/include/stdlib.h" 3 4 extern _Float32 strtof32 (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); extern _Float64 strtof64 (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); extern _Float128 strtof128 (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); extern _Float32x strtof32x (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); extern _Float64x strtof64x (const char *__restrict __nptr, char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); # 176 "/usr/include/stdlib.h" 3 4 extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) throw () __attribute__ ((__nonnull__ (1))); extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) throw () __attribute__ ((__nonnull__ (1))); __extension__ extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) throw () __attribute__ ((__nonnull__ (1))); __extension__ extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) throw () __attribute__ ((__nonnull__ (1))); __extension__ extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) throw () __attribute__ ((__nonnull__ (1))); __extension__ extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) throw () __attribute__ ((__nonnull__ (1))); extern int strfromd (char *__dest, size_t __size, const char *__format, double __f) throw () __attribute__ ((__nonnull__ (3))); extern int strfromf (char *__dest, size_t __size, const char *__format, float __f) throw () __attribute__ ((__nonnull__ (3))); extern int strfroml (char *__dest, size_t __size, const char *__format, long double __f) throw () __attribute__ ((__nonnull__ (3))); # 232 "/usr/include/stdlib.h" 3 4 extern int strfromf32 (char *__dest, size_t __size, const char * __format, _Float32 __f) throw () __attribute__ ((__nonnull__ (3))); extern int strfromf64 (char *__dest, size_t __size, const char * __format, _Float64 __f) throw () __attribute__ ((__nonnull__ (3))); extern int strfromf128 (char *__dest, size_t __size, const char * __format, _Float128 __f) throw () __attribute__ ((__nonnull__ (3))); extern int strfromf32x (char *__dest, size_t __size, const char * __format, _Float32x __f) throw () __attribute__ ((__nonnull__ (3))); extern int strfromf64x (char *__dest, size_t __size, const char * __format, _Float64x __f) throw () __attribute__ ((__nonnull__ (3))); # 274 "/usr/include/stdlib.h" 3 4 extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); __extension__ extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); __extension__ extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); extern double strtod_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); extern float strtof_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); extern long double strtold_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); # 316 "/usr/include/stdlib.h" 3 4 extern _Float32 strtof32_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); extern _Float64 strtof64_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); extern _Float128 strtof128_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); extern _Float32x strtof32x_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); extern _Float64x strtof64x_l (const char *__restrict __nptr, char **__restrict __endptr, locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3))); # 385 "/usr/include/stdlib.h" 3 4 extern char *l64a (long int __n) throw () ; extern long int a64l (const char *__s) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; # 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 extern "C" { typedef __u_char u_char; typedef __u_short u_short; typedef __u_int u_int; typedef __u_long u_long; typedef __quad_t quad_t; typedef __u_quad_t u_quad_t; typedef __fsid_t fsid_t; typedef __loff_t loff_t; typedef __ino_t ino_t; typedef __ino64_t ino64_t; typedef __dev_t dev_t; typedef __gid_t gid_t; typedef __mode_t mode_t; typedef __nlink_t nlink_t; typedef __uid_t uid_t; typedef __off_t off_t; typedef __off64_t off64_t; typedef __pid_t pid_t; typedef __id_t id_t; typedef __ssize_t ssize_t; typedef __daddr_t daddr_t; typedef __caddr_t caddr_t; typedef __key_t key_t; # 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4 typedef __clock_t clock_t; # 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4 typedef __clockid_t clockid_t; # 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4 typedef __time_t time_t; # 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4 typedef __timer_t timer_t; # 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 typedef __useconds_t useconds_t; typedef __suseconds_t suseconds_t; # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 typedef unsigned long int ulong; typedef unsigned short int ushort; typedef unsigned int uint; typedef __uint8_t u_int8_t; typedef __uint16_t u_int16_t; typedef __uint32_t u_int32_t; typedef __uint64_t u_int64_t; typedef int register_t __attribute__ ((__mode__ (__word__))); # 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 # 1 "/usr/include/endian.h" 1 3 4 # 35 "/usr/include/endian.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4 # 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 static __inline __uint16_t __bswap_16 (__uint16_t __bsx) { return __builtin_bswap16 (__bsx); } static __inline __uint32_t __bswap_32 (__uint32_t __bsx) { return __builtin_bswap32 (__bsx); } # 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4 __extension__ static __inline __uint64_t __bswap_64 (__uint64_t __bsx) { return __builtin_bswap64 (__bsx); } # 36 "/usr/include/endian.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4 # 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4 static __inline __uint16_t __uint16_identity (__uint16_t __x) { return __x; } static __inline __uint32_t __uint32_identity (__uint32_t __x) { return __x; } static __inline __uint64_t __uint64_identity (__uint64_t __x) { return __x; } # 37 "/usr/include/endian.h" 2 3 4 # 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4 # 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4 # 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4 # 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4 typedef struct { unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; } __sigset_t; # 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4 typedef __sigset_t sigset_t; # 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4 struct timeval { __time_t tv_sec; __suseconds_t tv_usec; }; # 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4 # 10 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 struct timespec { __time_t tv_sec; __syscall_slong_t tv_nsec; # 26 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4 }; # 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4 # 49 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 typedef long int __fd_mask; # 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 typedef struct { __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; } fd_set; typedef __fd_mask fd_mask; # 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 extern "C" { # 101 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 extern int select (int __nfds, fd_set *__restrict __readfds, fd_set *__restrict __writefds, fd_set *__restrict __exceptfds, struct timeval *__restrict __timeout); # 113 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 extern int pselect (int __nfds, fd_set *__restrict __readfds, fd_set *__restrict __writefds, fd_set *__restrict __exceptfds, const struct timespec *__restrict __timeout, const __sigset_t *__restrict __sigmask); # 126 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4 } # 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 typedef __blksize_t blksize_t; typedef __blkcnt_t blkcnt_t; typedef __fsblkcnt_t fsblkcnt_t; typedef __fsfilcnt_t fsfilcnt_t; # 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4 typedef __blkcnt64_t blkcnt64_t; typedef __fsblkcnt64_t fsblkcnt64_t; typedef __fsfilcnt64_t fsfilcnt64_t; # 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4 # 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4 # 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4 # 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4 # 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 typedef struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; } __pthread_list_t; typedef struct __pthread_internal_slist { struct __pthread_internal_slist *__next; } __pthread_slist_t; # 74 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4 # 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4 struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner; unsigned int __nusers; int __kind; short __spins; short __elision; __pthread_list_t __list; # 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4 }; # 75 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 # 87 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4 # 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 struct __pthread_rwlock_arch_t { unsigned int __readers; unsigned int __writers; unsigned int __wrphase_futex; unsigned int __writers_futex; unsigned int __pad3; unsigned int __pad4; int __cur_writer; int __shared; signed char __rwelision; unsigned char __pad1[7]; unsigned long int __pad2; unsigned int __flags; # 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4 }; # 88 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4 struct __pthread_cond_s { __extension__ union { __extension__ unsigned long long int __wseq; struct { unsigned int __low; unsigned int __high; } __wseq32; }; __extension__ union { __extension__ unsigned long long int __g1_start; struct { unsigned int __low; unsigned int __high; } __g1_start32; }; unsigned int __g_refs[2] ; unsigned int __g_size[2]; unsigned int __g1_orig_size; unsigned int __wrefs; unsigned int __g_signals[2]; }; # 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4 typedef unsigned long int pthread_t; typedef union { char __size[4]; int __align; } pthread_mutexattr_t; typedef union { char __size[4]; int __align; } pthread_condattr_t; typedef unsigned int pthread_key_t; typedef int pthread_once_t; union pthread_attr_t { char __size[56]; long int __align; }; typedef union pthread_attr_t pthread_attr_t; typedef union { struct __pthread_mutex_s __data; char __size[40]; long int __align; } pthread_mutex_t; typedef union { struct __pthread_cond_s __data; char __size[48]; __extension__ long long int __align; } pthread_cond_t; typedef union { struct __pthread_rwlock_arch_t __data; char __size[56]; long int __align; } pthread_rwlock_t; typedef union { char __size[8]; long int __align; } pthread_rwlockattr_t; typedef volatile int pthread_spinlock_t; typedef union { char __size[32]; long int __align; } pthread_barrier_t; typedef union { char __size[4]; int __align; } pthread_barrierattr_t; # 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4 } # 395 "/usr/include/stdlib.h" 2 3 4 extern long int random (void) throw (); extern void srandom (unsigned int __seed) throw (); extern char *initstate (unsigned int __seed, char *__statebuf, size_t __statelen) throw () __attribute__ ((__nonnull__ (2))); extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1))); struct random_data { int32_t *fptr; int32_t *rptr; int32_t *state; int rand_type; int rand_deg; int rand_sep; int32_t *end_ptr; }; extern int random_r (struct random_data *__restrict __buf, int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); extern int srandom_r (unsigned int __seed, struct random_data *__buf) throw () __attribute__ ((__nonnull__ (2))); extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, size_t __statelen, struct random_data *__restrict __buf) throw () __attribute__ ((__nonnull__ (2, 4))); extern int setstate_r (char *__restrict __statebuf, struct random_data *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2))); extern int rand (void) throw (); extern void srand (unsigned int __seed) throw (); extern int rand_r (unsigned int *__seed) throw (); extern double drand48 (void) throw (); extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); extern long int lrand48 (void) throw (); extern long int nrand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); extern long int mrand48 (void) throw (); extern long int jrand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); extern void srand48 (long int __seedval) throw (); extern unsigned short int *seed48 (unsigned short int __seed16v[3]) throw () __attribute__ ((__nonnull__ (1))); extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1))); struct drand48_data { unsigned short int __x[3]; unsigned short int __old_x[3]; unsigned short int __c; unsigned short int __init; __extension__ unsigned long long int __a; }; extern int drand48_r (struct drand48_data *__restrict __buffer, double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); extern int erand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); extern int lrand48_r (struct drand48_data *__restrict __buffer, long int *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); extern int nrand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, long int *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); extern int mrand48_r (struct drand48_data *__restrict __buffer, long int *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); extern int jrand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, long int *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); extern int srand48_r (long int __seedval, struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (2))); extern int seed48_r (unsigned short int __seed16v[3], struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2))); extern int lcong48_r (unsigned short int __param[7], struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2))); extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1))) ; extern void *calloc (size_t __nmemb, size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; extern void *realloc (void *__ptr, size_t __size) throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2, 3))); extern void free (void *__ptr) throw (); # 1 "/usr/include/alloca.h" 1 3 4 # 24 "/usr/include/alloca.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 25 "/usr/include/alloca.h" 2 3 4 extern "C" { extern void *alloca (size_t __size) throw (); } # 569 "/usr/include/stdlib.h" 2 3 4 extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1))) ; extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) throw () __attribute__ ((__nonnull__ (1))) ; extern void *aligned_alloc (size_t __alignment, size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ; extern void abort (void) throw () __attribute__ ((__noreturn__)); extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1))); extern "C++" int at_quick_exit (void (*__func) (void)) throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); # 610 "/usr/include/stdlib.h" 3 4 extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) throw () __attribute__ ((__nonnull__ (1))); extern void exit (int __status) throw () __attribute__ ((__noreturn__)); extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__)); extern void _Exit (int __status) throw () __attribute__ ((__noreturn__)); extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; extern char *secure_getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1))); extern int setenv (const char *__name, const char *__value, int __replace) throw () __attribute__ ((__nonnull__ (2))); extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))); extern int clearenv (void) throw (); # 675 "/usr/include/stdlib.h" 3 4 extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))); # 688 "/usr/include/stdlib.h" 3 4 extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; # 698 "/usr/include/stdlib.h" 3 4 extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; # 710 "/usr/include/stdlib.h" 3 4 extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; # 720 "/usr/include/stdlib.h" 3 4 extern int mkstemps64 (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; # 731 "/usr/include/stdlib.h" 3 4 extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ; # 742 "/usr/include/stdlib.h" 3 4 extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; # 752 "/usr/include/stdlib.h" 3 4 extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; # 762 "/usr/include/stdlib.h" 3 4 extern int mkostemps (char *__template, int __suffixlen, int __flags) __attribute__ ((__nonnull__ (1))) ; # 774 "/usr/include/stdlib.h" 3 4 extern int mkostemps64 (char *__template, int __suffixlen, int __flags) __attribute__ ((__nonnull__ (1))) ; # 784 "/usr/include/stdlib.h" 3 4 extern int system (const char *__command) ; extern char *canonicalize_file_name (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; # 800 "/usr/include/stdlib.h" 3 4 extern char *realpath (const char *__restrict __name, char *__restrict __resolved) throw () ; typedef int (*__compar_fn_t) (const void *, const void *); typedef __compar_fn_t comparison_fn_t; typedef int (*__compar_d_fn_t) (const void *, const void *, void *); extern void *bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 2, 5))) ; extern void qsort (void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); extern void qsort_r (void *__base, size_t __nmemb, size_t __size, __compar_d_fn_t __compar, void *__arg) __attribute__ ((__nonnull__ (1, 4))); extern int abs (int __x) throw () __attribute__ ((__const__)) ; extern long int labs (long int __x) throw () __attribute__ ((__const__)) ; __extension__ extern long long int llabs (long long int __x) throw () __attribute__ ((__const__)) ; extern div_t div (int __numer, int __denom) throw () __attribute__ ((__const__)) ; extern ldiv_t ldiv (long int __numer, long int __denom) throw () __attribute__ ((__const__)) ; __extension__ extern lldiv_t lldiv (long long int __numer, long long int __denom) throw () __attribute__ ((__const__)) ; # 872 "/usr/include/stdlib.h" 3 4 extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; extern char *gcvt (double __value, int __ndigit, char *__buf) throw () __attribute__ ((__nonnull__ (3))) ; extern char *qecvt (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; extern char *qfcvt (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; extern char *qgcvt (long double __value, int __ndigit, char *__buf) throw () __attribute__ ((__nonnull__ (3))) ; extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); extern int qecvt_r (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); extern int qfcvt_r (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); extern int mblen (const char *__s, size_t __n) throw (); extern int mbtowc (wchar_t *__restrict __pwc, const char *__restrict __s, size_t __n) throw (); extern int wctomb (char *__s, wchar_t __wchar) throw (); extern size_t mbstowcs (wchar_t *__restrict __pwcs, const char *__restrict __s, size_t __n) throw (); extern size_t wcstombs (char *__restrict __s, const wchar_t *__restrict __pwcs, size_t __n) throw (); extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ; # 957 "/usr/include/stdlib.h" 3 4 extern int getsubopt (char **__restrict __optionp, char *const *__restrict __tokens, char **__restrict __valuep) throw () __attribute__ ((__nonnull__ (1, 2, 3))) ; extern int posix_openpt (int __oflag) ; extern int grantpt (int __fd) throw (); extern int unlockpt (int __fd) throw (); extern char *ptsname (int __fd) throw () ; extern int ptsname_r (int __fd, char *__buf, size_t __buflen) throw () __attribute__ ((__nonnull__ (2))); extern int getpt (void); extern int getloadavg (double __loadavg[], int __nelem) throw () __attribute__ ((__nonnull__ (1))); # 1013 "/usr/include/stdlib.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4 # 1014 "/usr/include/stdlib.h" 2 3 4 # 1023 "/usr/include/stdlib.h" 3 4 } # 76 "/usr/include/c++/10/cstdlib" 2 3 # 1 "/usr/include/c++/10/bits/std_abs.h" 1 3 # 33 "/usr/include/c++/10/bits/std_abs.h" 3 # 34 "/usr/include/c++/10/bits/std_abs.h" 3 # 46 "/usr/include/c++/10/bits/std_abs.h" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::abs; inline long abs(long __i) { return __builtin_labs(__i); } inline long long abs(long long __x) { return __builtin_llabs (__x); } # 70 "/usr/include/c++/10/bits/std_abs.h" 3 inline constexpr double abs(double __x) { return __builtin_fabs(__x); } inline constexpr float abs(float __x) { return __builtin_fabsf(__x); } inline constexpr long double abs(long double __x) { return __builtin_fabsl(__x); } # 107 "/usr/include/c++/10/bits/std_abs.h" 3 } } # 78 "/usr/include/c++/10/cstdlib" 2 3 # 121 "/usr/include/c++/10/cstdlib" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::div_t; using ::ldiv_t; using ::abort; using ::aligned_alloc; using ::atexit; using ::at_quick_exit; using ::atof; using ::atoi; using ::atol; using ::bsearch; using ::calloc; using ::div; using ::exit; using ::free; using ::getenv; using ::labs; using ::ldiv; using ::malloc; using ::mblen; using ::mbstowcs; using ::mbtowc; using ::qsort; using ::quick_exit; using ::rand; using ::realloc; using ::srand; using ::strtod; using ::strtol; using ::strtoul; using ::system; using ::wcstombs; using ::wctomb; inline ldiv_t div(long __i, long __j) { return ldiv(__i, __j); } } # 195 "/usr/include/c++/10/cstdlib" 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { using ::lldiv_t; using ::_Exit; using ::llabs; inline lldiv_t div(long long __n, long long __d) { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } using ::lldiv; # 227 "/usr/include/c++/10/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; } } # 60 "/usr/include/c++/10/bits/stl_algo.h" 2 3 # 1 "/usr/include/c++/10/bits/algorithmfwd.h" 1 3 # 33 "/usr/include/c++/10/bits/algorithmfwd.h" 3 # 34 "/usr/include/c++/10/bits/algorithmfwd.h" 3 # 42 "/usr/include/c++/10/bits/algorithmfwd.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 199 "/usr/include/c++/10/bits/algorithmfwd.h" 3 template constexpr bool all_of(_IIter, _IIter, _Predicate); template constexpr bool any_of(_IIter, _IIter, _Predicate); template constexpr bool binary_search(_FIter, _FIter, const _Tp&); template constexpr bool binary_search(_FIter, _FIter, const _Tp&, _Compare); template constexpr const _Tp& clamp(const _Tp&, const _Tp&, const _Tp&); template constexpr const _Tp& clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); template constexpr _OIter copy(_IIter, _IIter, _OIter); template constexpr _BIter2 copy_backward(_BIter1, _BIter1, _BIter2); template constexpr _OIter copy_if(_IIter, _IIter, _OIter, _Predicate); template constexpr _OIter copy_n(_IIter, _Size, _OIter); template constexpr pair<_FIter, _FIter> equal_range(_FIter, _FIter, const _Tp&); template constexpr pair<_FIter, _FIter> equal_range(_FIter, _FIter, const _Tp&, _Compare); template constexpr void fill(_FIter, _FIter, const _Tp&); template constexpr _OIter fill_n(_OIter, _Size, const _Tp&); template constexpr _FIter1 find_end(_FIter1, _FIter1, _FIter2, _FIter2); template constexpr _FIter1 find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); template constexpr _IIter find_if_not(_IIter, _IIter, _Predicate); template constexpr bool includes(_IIter1, _IIter1, _IIter2, _IIter2); template constexpr bool includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); template void inplace_merge(_BIter, _BIter, _BIter); template void inplace_merge(_BIter, _BIter, _BIter, _Compare); template constexpr bool is_heap(_RAIter, _RAIter); template constexpr bool is_heap(_RAIter, _RAIter, _Compare); template constexpr _RAIter is_heap_until(_RAIter, _RAIter); template constexpr _RAIter is_heap_until(_RAIter, _RAIter, _Compare); template constexpr bool is_partitioned(_IIter, _IIter, _Predicate); template constexpr bool is_permutation(_FIter1, _FIter1, _FIter2); template constexpr bool is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); template constexpr bool is_sorted(_FIter, _FIter); template constexpr bool is_sorted(_FIter, _FIter, _Compare); template constexpr _FIter is_sorted_until(_FIter, _FIter); template constexpr _FIter is_sorted_until(_FIter, _FIter, _Compare); template constexpr void iter_swap(_FIter1, _FIter2); template constexpr _FIter lower_bound(_FIter, _FIter, const _Tp&); template constexpr _FIter lower_bound(_FIter, _FIter, const _Tp&, _Compare); template constexpr void make_heap(_RAIter, _RAIter); template constexpr void make_heap(_RAIter, _RAIter, _Compare); template constexpr const _Tp& max(const _Tp&, const _Tp&); template constexpr const _Tp& max(const _Tp&, const _Tp&, _Compare); template constexpr const _Tp& min(const _Tp&, const _Tp&); template constexpr const _Tp& min(const _Tp&, const _Tp&, _Compare); template constexpr pair minmax(const _Tp&, const _Tp&); template constexpr pair minmax(const _Tp&, const _Tp&, _Compare); template constexpr pair<_FIter, _FIter> minmax_element(_FIter, _FIter); template constexpr pair<_FIter, _FIter> minmax_element(_FIter, _FIter, _Compare); template constexpr _Tp min(initializer_list<_Tp>); template constexpr _Tp min(initializer_list<_Tp>, _Compare); template constexpr _Tp max(initializer_list<_Tp>); template constexpr _Tp max(initializer_list<_Tp>, _Compare); template constexpr pair<_Tp, _Tp> minmax(initializer_list<_Tp>); template constexpr pair<_Tp, _Tp> minmax(initializer_list<_Tp>, _Compare); template constexpr bool next_permutation(_BIter, _BIter); template constexpr bool next_permutation(_BIter, _BIter, _Compare); template constexpr bool none_of(_IIter, _IIter, _Predicate); template constexpr _RAIter partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); template constexpr _RAIter partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); template constexpr pair<_OIter1, _OIter2> partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); template constexpr _FIter partition_point(_FIter, _FIter, _Predicate); template constexpr void pop_heap(_RAIter, _RAIter); template constexpr void pop_heap(_RAIter, _RAIter, _Compare); template constexpr bool prev_permutation(_BIter, _BIter); template constexpr bool prev_permutation(_BIter, _BIter, _Compare); template constexpr void push_heap(_RAIter, _RAIter); template constexpr void push_heap(_RAIter, _RAIter, _Compare); template constexpr _FIter remove(_FIter, _FIter, const _Tp&); template constexpr _FIter remove_if(_FIter, _FIter, _Predicate); template constexpr _OIter remove_copy(_IIter, _IIter, _OIter, const _Tp&); template constexpr _OIter remove_copy_if(_IIter, _IIter, _OIter, _Predicate); template constexpr _OIter replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); template constexpr _OIter replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); template constexpr void reverse(_BIter, _BIter); template constexpr _OIter reverse_copy(_BIter, _BIter, _OIter); inline namespace _V2 { template constexpr _FIter rotate(_FIter, _FIter, _FIter); } template constexpr _OIter rotate_copy(_FIter, _FIter, _FIter, _OIter); # 625 "/usr/include/c++/10/bits/algorithmfwd.h" 3 template void shuffle(_RAIter, _RAIter, _UGenerator&&); template constexpr void sort_heap(_RAIter, _RAIter); template constexpr void sort_heap(_RAIter, _RAIter, _Compare); template _BIter stable_partition(_BIter, _BIter, _Predicate); # 658 "/usr/include/c++/10/bits/algorithmfwd.h" 3 template constexpr _FIter2 swap_ranges(_FIter1, _FIter1, _FIter2); template constexpr _FIter unique(_FIter, _FIter); template constexpr _FIter unique(_FIter, _FIter, _BinaryPredicate); template constexpr _FIter upper_bound(_FIter, _FIter, const _Tp&); template constexpr _FIter upper_bound(_FIter, _FIter, const _Tp&, _Compare); template constexpr _FIter adjacent_find(_FIter, _FIter); template constexpr _FIter adjacent_find(_FIter, _FIter, _BinaryPredicate); template constexpr typename iterator_traits<_IIter>::difference_type count(_IIter, _IIter, const _Tp&); template constexpr typename iterator_traits<_IIter>::difference_type count_if(_IIter, _IIter, _Predicate); template constexpr bool equal(_IIter1, _IIter1, _IIter2); template constexpr bool equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); template constexpr _IIter find(_IIter, _IIter, const _Tp&); template constexpr _FIter1 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); template constexpr _FIter1 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); template constexpr _IIter find_if(_IIter, _IIter, _Predicate); template constexpr _Funct for_each(_IIter, _IIter, _Funct); template constexpr void generate(_FIter, _FIter, _Generator); template constexpr _OIter generate_n(_OIter, _Size, _Generator); template constexpr bool lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); template constexpr bool lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); template constexpr _FIter max_element(_FIter, _FIter); template constexpr _FIter max_element(_FIter, _FIter, _Compare); template constexpr _OIter merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template constexpr _OIter merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template constexpr _FIter min_element(_FIter, _FIter); template constexpr _FIter min_element(_FIter, _FIter, _Compare); template constexpr pair<_IIter1, _IIter2> mismatch(_IIter1, _IIter1, _IIter2); template constexpr pair<_IIter1, _IIter2> mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); template constexpr void nth_element(_RAIter, _RAIter, _RAIter); template constexpr void nth_element(_RAIter, _RAIter, _RAIter, _Compare); template constexpr void partial_sort(_RAIter, _RAIter, _RAIter); template constexpr void partial_sort(_RAIter, _RAIter, _RAIter, _Compare); template constexpr _BIter partition(_BIter, _BIter, _Predicate); template void random_shuffle(_RAIter, _RAIter); template void random_shuffle(_RAIter, _RAIter, _Generator&&); template constexpr void replace(_FIter, _FIter, const _Tp&, const _Tp&); template constexpr void replace_if(_FIter, _FIter, _Predicate, const _Tp&); template constexpr _FIter1 search(_FIter1, _FIter1, _FIter2, _FIter2); template constexpr _FIter1 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); template constexpr _FIter search_n(_FIter, _FIter, _Size, const _Tp&); template constexpr _FIter search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); template constexpr _OIter set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template constexpr _OIter set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template constexpr _OIter set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template constexpr _OIter set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template constexpr _OIter set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template constexpr _OIter set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template constexpr _OIter set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); template constexpr _OIter set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); template constexpr void sort(_RAIter, _RAIter); template constexpr void sort(_RAIter, _RAIter, _Compare); template void stable_sort(_RAIter, _RAIter); template void stable_sort(_RAIter, _RAIter, _Compare); template constexpr _OIter transform(_IIter, _IIter, _OIter, _UnaryOperation); template constexpr _OIter transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); template constexpr _OIter unique_copy(_IIter, _IIter, _OIter); template constexpr _OIter unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); } # 61 "/usr/include/c++/10/bits/stl_algo.h" 2 3 # 1 "/usr/include/c++/10/bits/stl_heap.h" 1 3 # 62 "/usr/include/c++/10/bits/stl_heap.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template 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 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 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 constexpr inline bool __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { return std::__is_heap(__first, std::distance(__first, __last)); } template constexpr inline bool __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { return std::__is_heap(__first, std::move(__comp), std::distance(__first, __last)); } template 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); } # 158 "/usr/include/c++/10/bits/stl_heap.h" 3 template 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); } # 194 "/usr/include/c++/10/bits/stl_heap.h" 3 template 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 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 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); } # 279 "/usr/include/c++/10/bits/stl_heap.h" 3 template 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); } } # 313 "/usr/include/c++/10/bits/stl_heap.h" 3 template 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 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--; } } # 371 "/usr/include/c++/10/bits/stl_heap.h" 3 template constexpr inline void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; __gnu_cxx::__ops::_Iter_less_iter __comp; std::__make_heap(__first, __last, __comp); } # 398 "/usr/include/c++/10/bits/stl_heap.h" 3 template 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 constexpr void __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) { while (__last - __first > 1) { --__last; std::__pop_heap(__first, __last, __last, __comp); } } # 436 "/usr/include/c++/10/bits/stl_heap.h" 3 template constexpr inline void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; ; __gnu_cxx::__ops::_Iter_less_iter __comp; std::__sort_heap(__first, __last, __comp); } # 464 "/usr/include/c++/10/bits/stl_heap.h" 3 template constexpr inline void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; ; typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); std::__sort_heap(__first, __last, __cmp); } # 493 "/usr/include/c++/10/bits/stl_heap.h" 3 template constexpr inline _RandomAccessIterator is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; __gnu_cxx::__ops::_Iter_less_iter __comp; return __first + std::__is_heap_until(__first, std::distance(__first, __last), __comp); } # 522 "/usr/include/c++/10/bits/stl_heap.h" 3 template constexpr inline _RandomAccessIterator is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); return __first + std::__is_heap_until(__first, std::distance(__first, __last), __cmp); } # 547 "/usr/include/c++/10/bits/stl_heap.h" 3 template constexpr inline bool is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) { return std::is_heap_until(__first, __last) == __last; } # 561 "/usr/include/c++/10/bits/stl_heap.h" 3 template constexpr inline bool is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; const auto __dist = std::distance(__first, __last); typedef __decltype(__comp) _Cmp; __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); return std::__is_heap_until(__first, __dist, __cmp) == __dist; } } # 62 "/usr/include/c++/10/bits/stl_algo.h" 2 3 # 1 "/usr/include/c++/10/bits/stl_tempbuf.h" 1 3 # 60 "/usr/include/c++/10/bits/stl_tempbuf.h" 3 # 1 "/usr/include/c++/10/bits/stl_construct.h" 1 3 # 73 "/usr/include/c++/10/bits/stl_construct.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template constexpr inline void destroy_at(_Tp* __location) { if constexpr (201709L > 201703L && is_array_v<_Tp>) { for (auto& __x : *__location) std::destroy_at(std::__addressof(__x)); } else __location->~_Tp(); } template 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 "/usr/include/c++/10/bits/stl_construct.h" 3 template inline void _Construct(_Tp* __p, _Args&&... __args) { ::new(static_cast(__p)) _Tp(std::forward<_Args>(__args)...); } # 121 "/usr/include/c++/10/bits/stl_construct.h" 3 template inline void _Construct_novalue(_T1* __p) { ::new(static_cast(__p)) _T1; } template constexpr void _Destroy(_ForwardIterator __first, _ForwardIterator __last); template constexpr inline void _Destroy(_Tp* __pointer) { std::destroy_at(__pointer); } template struct _Destroy_aux { template static constexpr void __destroy(_ForwardIterator __first, _ForwardIterator __last) { for (; __first != __last; ++__first) std::_Destroy(std::__addressof(*__first)); } }; template<> struct _Destroy_aux { template static void __destroy(_ForwardIterator, _ForwardIterator) { } }; template 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 _Destroy_aux::__destroy(__first, __last); std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: __destroy(__first, __last); } template struct _Destroy_n_aux { template 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 { template static _ForwardIterator __destroy_n(_ForwardIterator __first, _Size __count) { std::advance(__first, __count); return __first; } }; template 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 _Destroy_n_aux::__destroy_n(__first, __count); return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: __destroy_n(__first, __count); } template constexpr inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { std::_Destroy(__first, __last); } template constexpr inline _ForwardIterator destroy_n(_ForwardIterator __first, _Size __count) { return std::_Destroy_n(__first, __count); } } # 61 "/usr/include/c++/10/bits/stl_tempbuf.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template inline void __return_temporary_buffer(_Tp* __p, size_t __len __attribute__((__unused__))) { ::operator delete(__p, __len * sizeof(_Tp)); } } # 98 "/usr/include/c++/10/bits/stl_tempbuf.h" 3 template pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) noexcept { const ptrdiff_t __max = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); if (__len > __max) __len = __max; while (__len > 0) { _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), std::nothrow)); if (__tmp != 0) return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); __len /= 2; } return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); } # 125 "/usr/include/c++/10/bits/stl_tempbuf.h" 3 template inline void return_temporary_buffer(_Tp* __p) { ::operator delete(__p); } template class _Temporary_buffer { public: typedef _Tp value_type; typedef value_type* pointer; typedef pointer iterator; typedef ptrdiff_t size_type; protected: size_type _M_original_len; size_type _M_len; pointer _M_buffer; public: size_type size() const { return _M_len; } size_type requested_size() const { return _M_original_len; } iterator begin() { return _M_buffer; } iterator end() { return _M_buffer + _M_len; } _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); ~_Temporary_buffer() { std::_Destroy(_M_buffer, _M_buffer + _M_len); std::__detail::__return_temporary_buffer(_M_buffer, _M_len); } private: _Temporary_buffer(const _Temporary_buffer&); void operator=(const _Temporary_buffer&); }; template struct __uninitialized_construct_buf_dispatch { template static void __ucr(_Pointer __first, _Pointer __last, _ForwardIterator __seed) { if (__first == __last) return; _Pointer __cur = __first; try { std::_Construct(std::__addressof(*__first), std::move(*__seed)); _Pointer __prev = __cur; ++__cur; for(; __cur != __last; ++__cur, ++__prev) std::_Construct(std::__addressof(*__cur), std::move(*__prev)); *__seed = std::move(*__prev); } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_construct_buf_dispatch { template static void __ucr(_Pointer, _Pointer, _ForwardIterator) { } }; # 243 "/usr/include/c++/10/bits/stl_tempbuf.h" 3 template inline void __uninitialized_construct_buf(_Pointer __first, _Pointer __last, _ForwardIterator __seed) { typedef typename std::iterator_traits<_Pointer>::value_type _ValueType; std::__uninitialized_construct_buf_dispatch< __has_trivial_constructor(_ValueType)>:: __ucr(__first, __last, __seed); } template _Temporary_buffer<_ForwardIterator, _Tp>:: _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) : _M_original_len(__original_len), _M_len(0), _M_buffer(0) { std::pair __p( std::get_temporary_buffer(_M_original_len)); if (__p.first) { try { std::__uninitialized_construct_buf(__p.first, __p.first + __p.second, __seed); _M_buffer = __p.first; _M_len = __p.second; } catch(...) { std::__detail::__return_temporary_buffer(__p.first, __p.second); throw; } } } } # 63 "/usr/include/c++/10/bits/stl_algo.h" 2 3 # 1 "/usr/include/c++/10/bits/uniform_int_dist.h" 1 3 # 35 "/usr/include/c++/10/bits/uniform_int_dist.h" 3 # 1 "/usr/include/c++/10/limits" 1 3 # 40 "/usr/include/c++/10/limits" 3 # 41 "/usr/include/c++/10/limits" 3 # 158 "/usr/include/c++/10/limits" 3 namespace std __attribute__ ((__visibility__ ("default"))) { enum float_round_style { round_indeterminate = -1, round_toward_zero = 0, round_to_nearest = 1, round_toward_infinity = 2, round_toward_neg_infinity = 3 }; enum float_denorm_style { denorm_indeterminate = -1, denorm_absent = 0, denorm_present = 1 }; # 202 "/usr/include/c++/10/limits" 3 struct __numeric_limits_base { static constexpr bool is_specialized = false; static constexpr int digits = 0; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 0; static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr bool is_iec559 = false; static constexpr bool is_bounded = false; # 288 "/usr/include/c++/10/limits" 3 static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; # 311 "/usr/include/c++/10/limits" 3 template struct numeric_limits : public __numeric_limits_base { static constexpr _Tp min() noexcept { return _Tp(); } static constexpr _Tp max() noexcept { return _Tp(); } static constexpr _Tp lowest() noexcept { return _Tp(); } static constexpr _Tp epsilon() noexcept { return _Tp(); } static constexpr _Tp round_error() noexcept { return _Tp(); } static constexpr _Tp infinity() noexcept { return _Tp(); } static constexpr _Tp quiet_NaN() noexcept { return _Tp(); } static constexpr _Tp signaling_NaN() noexcept { return _Tp(); } static constexpr _Tp denorm_min() noexcept { return _Tp(); } }; template struct numeric_limits : public numeric_limits<_Tp> { }; template struct numeric_limits : public numeric_limits<_Tp> { }; template struct numeric_limits : public numeric_limits<_Tp> { }; # 383 "/usr/include/c++/10/limits" 3 template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr bool min() noexcept { return false; } static constexpr bool max() noexcept { return true; } static constexpr bool lowest() noexcept { return min(); } static constexpr int digits = 1; static constexpr int digits10 = 0; static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr bool epsilon() noexcept { return false; } static constexpr bool round_error() noexcept { return false; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr bool infinity() noexcept { return false; } static constexpr bool quiet_NaN() noexcept { return false; } static constexpr bool signaling_NaN() noexcept { return false; } static constexpr bool denorm_min() noexcept { return false; } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } static constexpr char max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } static constexpr char lowest() noexcept { return min(); } static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((char)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char epsilon() noexcept { return 0; } static constexpr char round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char infinity() noexcept { return char(); } static constexpr char quiet_NaN() noexcept { return char(); } static constexpr char signaling_NaN() noexcept { return char(); } static constexpr char denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr signed char min() noexcept { return -0x7f - 1; } static constexpr signed char max() noexcept { return 0x7f; } static constexpr signed char lowest() noexcept { return min(); } static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); static constexpr int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr signed char epsilon() noexcept { return 0; } static constexpr signed char round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr signed char infinity() noexcept { return static_cast(0); } static constexpr signed char quiet_NaN() noexcept { return static_cast(0); } static constexpr signed char signaling_NaN() noexcept { return static_cast(0); } static constexpr signed char denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned char min() noexcept { return 0; } static constexpr unsigned char max() noexcept { return 0x7f * 2U + 1; } static constexpr unsigned char lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned char epsilon() noexcept { return 0; } static constexpr unsigned char round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned char infinity() noexcept { return static_cast(0); } static constexpr unsigned char quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned char signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned char denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr wchar_t min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } static constexpr wchar_t max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } static constexpr wchar_t lowest() noexcept { return min(); } static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); static constexpr int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((wchar_t)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr wchar_t epsilon() noexcept { return 0; } static constexpr wchar_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr wchar_t infinity() noexcept { return wchar_t(); } static constexpr wchar_t quiet_NaN() noexcept { return wchar_t(); } static constexpr wchar_t signaling_NaN() noexcept { return wchar_t(); } static constexpr wchar_t denorm_min() noexcept { return wchar_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char8_t min() noexcept { return (((char8_t)(-1) < 0) ? -(((char8_t)(-1) < 0) ? (((((char8_t)1 << ((sizeof(char8_t) * 8 - ((char8_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char8_t)0) - 1 : (char8_t)0); } static constexpr char8_t max() noexcept { return (((char8_t)(-1) < 0) ? (((((char8_t)1 << ((sizeof(char8_t) * 8 - ((char8_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char8_t)0); } static constexpr char8_t lowest() noexcept { return min(); } static constexpr int digits = (sizeof(char8_t) * 8 - ((char8_t)(-1) < 0)); static constexpr int digits10 = ((sizeof(char8_t) * 8 - ((char8_t)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((char8_t)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char8_t epsilon() noexcept { return 0; } static constexpr char8_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr 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; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char16_t min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } static constexpr char16_t max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } static constexpr char16_t lowest() noexcept { return min(); } static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((char16_t)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char16_t epsilon() noexcept { return 0; } static constexpr char16_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char16_t infinity() noexcept { return char16_t(); } static constexpr char16_t quiet_NaN() noexcept { return char16_t(); } static constexpr char16_t signaling_NaN() noexcept { return char16_t(); } static constexpr char16_t denorm_min() noexcept { return char16_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr char32_t min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } static constexpr char32_t max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } static constexpr char32_t lowest() noexcept { return min(); } static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = ((char32_t)(-1) < 0); static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr char32_t epsilon() noexcept { return 0; } static constexpr char32_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr char32_t infinity() noexcept { return char32_t(); } static constexpr char32_t quiet_NaN() noexcept { return char32_t(); } static constexpr char32_t signaling_NaN() noexcept { return char32_t(); } static constexpr char32_t denorm_min() noexcept { return char32_t(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = !is_signed; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr short min() noexcept { return -0x7fff - 1; } static constexpr short max() noexcept { return 0x7fff; } static constexpr short lowest() noexcept { return min(); } static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr short epsilon() noexcept { return 0; } static constexpr short round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr short infinity() noexcept { return short(); } static constexpr short quiet_NaN() noexcept { return short(); } static constexpr short signaling_NaN() noexcept { return short(); } static constexpr short denorm_min() noexcept { return short(); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned short min() noexcept { return 0; } static constexpr unsigned short max() noexcept { return 0x7fff * 2U + 1; } static constexpr unsigned short lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned short epsilon() noexcept { return 0; } static constexpr unsigned short round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned short infinity() noexcept { return static_cast(0); } static constexpr unsigned short quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned short signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned short denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr int min() noexcept { return -0x7fffffff - 1; } static constexpr int max() noexcept { return 0x7fffffff; } static constexpr int lowest() noexcept { return min(); } static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr int epsilon() noexcept { return 0; } static constexpr int round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr int infinity() noexcept { return static_cast(0); } static constexpr int quiet_NaN() noexcept { return static_cast(0); } static constexpr int signaling_NaN() noexcept { return static_cast(0); } static constexpr int denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned int min() noexcept { return 0; } static constexpr unsigned int max() noexcept { return 0x7fffffff * 2U + 1; } static constexpr unsigned int lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned int epsilon() noexcept { return 0; } static constexpr unsigned int round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned int infinity() noexcept { return static_cast(0); } static constexpr unsigned int quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned int signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned int denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr long min() noexcept { return -0x7fffffffffffffffL - 1; } static constexpr long max() noexcept { return 0x7fffffffffffffffL; } static constexpr long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr long epsilon() noexcept { return 0; } static constexpr long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr long infinity() noexcept { return static_cast(0); } static constexpr long quiet_NaN() noexcept { return static_cast(0); } static constexpr long signaling_NaN() noexcept { return static_cast(0); } static constexpr long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned long min() noexcept { return 0; } static constexpr unsigned long max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; } static constexpr unsigned long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned long epsilon() noexcept { return 0; } static constexpr unsigned long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned long infinity() noexcept { return static_cast(0); } static constexpr unsigned long quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned long signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr long long min() noexcept { return -0x7fffffffffffffffLL - 1; } static constexpr long long max() noexcept { return 0x7fffffffffffffffLL; } static constexpr long long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0)); static constexpr int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr long long epsilon() noexcept { return 0; } static constexpr long long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr long long infinity() noexcept { return static_cast(0); } static constexpr long long quiet_NaN() noexcept { return static_cast(0); } static constexpr long long signaling_NaN() noexcept { return static_cast(0); } static constexpr long long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned long long min() noexcept { return 0; } static constexpr unsigned long long max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; } static constexpr unsigned long long lowest() noexcept { return min(); } static constexpr int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); static constexpr int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); static constexpr int max_digits10 = 0; static constexpr bool is_signed = false; static constexpr bool is_integer = true; static constexpr bool is_exact = true; static constexpr int radix = 2; static constexpr unsigned long long epsilon() noexcept { return 0; } static constexpr unsigned long long round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned long long infinity() noexcept { return static_cast(0); } static constexpr unsigned long long quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned long long signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned long long denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; # 1652 "/usr/include/c++/10/limits" 3 template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; 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 __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 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 __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; 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 __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 round_error() noexcept { return 0; } static constexpr int min_exponent = 0; static constexpr int min_exponent10 = 0; static constexpr int max_exponent = 0; static constexpr int max_exponent10 = 0; static constexpr bool has_infinity = false; static constexpr bool has_quiet_NaN = false; static constexpr bool has_signaling_NaN = false; static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr unsigned __int128 infinity() noexcept { return static_cast(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast(0); } static constexpr bool is_iec559 = false; static constexpr bool is_bounded = true; static constexpr bool is_modulo = true; static constexpr bool traps = true; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_toward_zero; }; # 1663 "/usr/include/c++/10/limits" 3 template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr float min() noexcept { return 1.17549435082228750796873653722224568e-38F; } static constexpr float max() noexcept { return 3.40282346638528859811704183484516925e+38F; } static constexpr float lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; } static constexpr int digits = 24; static constexpr int digits10 = 6; static constexpr int max_digits10 = (2 + (24) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr float epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; } static constexpr float round_error() noexcept { return 0.5F; } static constexpr int min_exponent = (-125); static constexpr int min_exponent10 = (-37); static constexpr int max_exponent = 128; static constexpr int max_exponent10 = 38; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr float infinity() noexcept { return __builtin_huge_valf(); } static constexpr float quiet_NaN() noexcept { return __builtin_nanf(""); } static constexpr float signaling_NaN() noexcept { return __builtin_nansf(""); } static constexpr float denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr double min() noexcept { return double(2.22507385850720138309023271733240406e-308L); } static constexpr double max() noexcept { return double(1.79769313486231570814527423731704357e+308L); } static constexpr double lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); } static constexpr int digits = 53; static constexpr int digits10 = 15; static constexpr int max_digits10 = (2 + (53) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr double epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); } static constexpr double round_error() noexcept { return 0.5; } static constexpr int min_exponent = (-1021); static constexpr int min_exponent10 = (-307); static constexpr int max_exponent = 1024; static constexpr int max_exponent10 = 308; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr double infinity() noexcept { return __builtin_huge_val(); } static constexpr double quiet_NaN() noexcept { return __builtin_nan(""); } static constexpr double signaling_NaN() noexcept { return __builtin_nans(""); } static constexpr double denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; template<> struct numeric_limits { static constexpr bool is_specialized = true; static constexpr long double min() noexcept { return 3.36210314311209350626267781732175260e-4932L; } static constexpr long double max() noexcept { return 1.18973149535723176502126385303097021e+4932L; } static constexpr long double lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; } static constexpr int digits = 64; static constexpr int digits10 = 18; static constexpr int max_digits10 = (2 + (64) * 643L / 2136); static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr int radix = 2; static constexpr long double epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; } static constexpr long double round_error() noexcept { return 0.5L; } static constexpr int min_exponent = (-16381); static constexpr int min_exponent10 = (-4931); static constexpr int max_exponent = 16384; static constexpr int max_exponent10 = 4932; static constexpr bool has_infinity = 1; static constexpr bool has_quiet_NaN = 1; static constexpr bool has_signaling_NaN = has_quiet_NaN; static constexpr float_denorm_style has_denorm = bool(1) ? denorm_present : denorm_absent; static constexpr bool has_denorm_loss = false; static constexpr long double infinity() noexcept { return __builtin_huge_vall(); } static constexpr long double quiet_NaN() noexcept { return __builtin_nanl(""); } static constexpr long double signaling_NaN() noexcept { return __builtin_nansl(""); } static constexpr long double denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; } static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present; static constexpr bool is_bounded = true; static constexpr bool is_modulo = false; static constexpr bool traps = false; static constexpr bool tinyness_before = false; static constexpr float_round_style round_style = round_to_nearest; }; } # 36 "/usr/include/c++/10/bits/uniform_int_dist.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template concept uniform_random_bit_generator = invocable<_Gen&> && unsigned_integral> && requires { { _Gen::min() } -> same_as>; { _Gen::max() } -> same_as>; requires bool_constant<(_Gen::min() < _Gen::max())>::value; }; namespace __detail { template inline bool _Power_of_2(_Tp __x) { return ((__x - 1) & __x) == 0; } } template class uniform_int_distribution { static_assert(std::is_integral<_IntType>::value, "template argument must be an integral type"); public: typedef _IntType result_type; struct param_type { typedef uniform_int_distribution<_IntType> distribution_type; param_type() : param_type(0) { } explicit param_type(_IntType __a, _IntType __b = numeric_limits<_IntType>::max()) : _M_a(__a), _M_b(__b) { ; } result_type a() const { return _M_a; } result_type b() const { return _M_b; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _IntType _M_a; _IntType _M_b; }; public: uniform_int_distribution() : uniform_int_distribution(0) { } explicit uniform_int_distribution(_IntType __a, _IntType __b = numeric_limits<_IntType>::max()) : _M_param(__a, __b) { } explicit uniform_int_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } result_type a() const { return _M_param.a(); } result_type b() const { return _M_param.b(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return this->a(); } result_type max() const { return this->b(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const uniform_int_distribution& __d1, const uniform_int_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template template typename uniform_int_distribution<_IntType>::result_type uniform_int_distribution<_IntType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { typedef typename _UniformRandomNumberGenerator::result_type _Gresult_type; typedef typename std::make_unsigned::type __utype; typedef typename std::common_type<_Gresult_type, __utype>::type __uctype; const __uctype __urngmin = __urng.min(); const __uctype __urngmax = __urng.max(); const __uctype __urngrange = __urngmax - __urngmin; const __uctype __urange = __uctype(__param.b()) - __uctype(__param.a()); __uctype __ret; if (__urngrange > __urange) { const __uctype __uerange = __urange + 1; const __uctype __scaling = __urngrange / __uerange; const __uctype __past = __uerange * __scaling; do __ret = __uctype(__urng()) - __urngmin; while (__ret >= __past); __ret /= __scaling; } else if (__urngrange < __urange) { # 287 "/usr/include/c++/10/bits/uniform_int_dist.h" 3 __uctype __tmp; do { const __uctype __uerngrange = __urngrange + 1; __tmp = (__uerngrange * operator() (__urng, param_type(0, __urange / __uerngrange))); __ret = __tmp + (__uctype(__urng()) - __urngmin); } while (__ret > __urange || __ret < __tmp); } else __ret = __uctype(__urng()) - __urngmin; return __ret + __param.a(); } template template void uniform_int_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { typedef typename _UniformRandomNumberGenerator::result_type _Gresult_type; typedef typename std::make_unsigned::type __utype; typedef typename std::common_type<_Gresult_type, __utype>::type __uctype; const __uctype __urngmin = __urng.min(); const __uctype __urngmax = __urng.max(); const __uctype __urngrange = __urngmax - __urngmin; const __uctype __urange = __uctype(__param.b()) - __uctype(__param.a()); __uctype __ret; if (__urngrange > __urange) { if (__detail::_Power_of_2(__urngrange + 1) && __detail::_Power_of_2(__urange + 1)) { while (__f != __t) { __ret = __uctype(__urng()) - __urngmin; *__f++ = (__ret & __urange) + __param.a(); } } else { const __uctype __uerange = __urange + 1; const __uctype __scaling = __urngrange / __uerange; const __uctype __past = __uerange * __scaling; while (__f != __t) { do __ret = __uctype(__urng()) - __urngmin; while (__ret >= __past); *__f++ = __ret / __scaling + __param.a(); } } } else if (__urngrange < __urange) { # 371 "/usr/include/c++/10/bits/uniform_int_dist.h" 3 __uctype __tmp; while (__f != __t) { do { const __uctype __uerngrange = __urngrange + 1; __tmp = (__uerngrange * operator() (__urng, param_type(0, __urange / __uerngrange))); __ret = __tmp + (__uctype(__urng()) - __urngmin); } while (__ret > __urange || __ret < __tmp); *__f++ = __ret; } } else while (__f != __t) *__f++ = __uctype(__urng()) - __urngmin + __param.a(); } } # 67 "/usr/include/c++/10/bits/stl_algo.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template 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 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 constexpr _InputIterator __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) { for (; __len; --__len, (void) ++__first) if (!__pred(__first)) break; return __first; } # 138 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 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 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 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 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 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; } } # 364 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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()); } # 413 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 449 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { return __last == std::find_if_not(__first, __last, __pred); } # 467 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { return __last == std::find_if(__first, __last, __pred); } # 486 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) { return !std::none_of(__first, __last, __pred); } # 502 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 527 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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); } # 549 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 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; } # 616 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 649 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 684 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 constexpr _OutputIterator __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result) { if (__n > 0) { while (true) { *__result = *__first; ++__result; if (--__n > 0) ++__first; else break; } } return __result; } template __enable_if_t<__is_char<_CharT>::__value, _CharT*> __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT>>, _Size, _CharT*); template 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))); } template constexpr inline _OutputIterator __copy_n(_RandomAccessIterator __first, _Size __n, _OutputIterator __result, random_access_iterator_tag) { return std::copy(__first, __first + __n, __result); } # 765 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 801 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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); } template 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; } # 872 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { ; return std::__remove_if(__first, __last, __gnu_cxx::__ops::__iter_equals_val(__value)); } # 906 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; return std::__remove_if(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } template 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 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; } # 975 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator unique(_ForwardIterator __first, _ForwardIterator __last) { ; return std::__unique(__first, __last, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 1006 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 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 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 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 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 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; } } # 1167 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline void reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; std::__reverse(__first, __last, std::__iterator_category(__first)); } # 1195 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr _OutputIterator reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) { ; while (__first != __last) { --__last; *__result = *__last; ++__result; } return __result; } template constexpr _EuclideanRingElement __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) { while (__n != 0) { _EuclideanRingElement __t = __m % __n; __m = __n; __n = __t; } return __m; } inline namespace _V2 { template 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 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 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; _Distance __n = __last - __first; _Distance __k = __middle - __first; if (__k == __n - __k) { std::swap_ranges(__first, __middle, __middle); return __middle; } _RandomAccessIterator __p = __first; _RandomAccessIterator __ret = __first + (__last - __middle); for (;;) { if (__k < __n - __k) { if (__is_pod(_ValueType) && __k == 1) { _ValueType __t = std::move(*__p); std::move(__p + 1, __p + __n, __p); *(__p + __n - 1) = std::move(__t); return __ret; } _RandomAccessIterator __q = __p + __k; for (_Distance __i = 0; __i < __n - __k; ++ __i) { std::iter_swap(__p, __q); ++__p; ++__q; } __n %= __k; if (__n == 0) return __ret; std::swap(__n, __k); __k = __n - __k; } else { __k = __n - __k; if (__is_pod(_ValueType) && __k == 1) { _ValueType __t = std::move(*(__p + __n - 1)); std::move_backward(__p, __p + __n - 1, __p + __n); *__p = std::move(__t); return __ret; } _RandomAccessIterator __q = __p + __n; __p = __q - __k; for (_Distance __i = 0; __i < __n - __k; ++ __i) { --__p; --__q; std::iter_swap(__p, __q); } __n %= __k; if (__n == 0) return __ret; std::swap(__n, __k); } } } # 1427 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) { ; ; return std::__rotate(__first, __middle, __last, std::__iterator_category(__first)); } } # 1465 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) { ; ; return std::copy(__first, __middle, std::copy(__middle, __last, __result)); } template 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 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; } } # 1545 "/usr/include/c++/10/bits/stl_algo.h" 3 template _ForwardIterator __stable_partition_adaptive(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _Distance __len, _Pointer __buffer, _Distance __buffer_size) { if (__len == 1) return __first; if (__len <= __buffer_size) { _ForwardIterator __result1 = __first; _Pointer __result2 = __buffer; *__result2 = std::move(*__first); ++__result2; ++__first; for (; __first != __last; ++__first) if (__pred(__first)) { *__result1 = std::move(*__first); ++__result1; } else { *__result2 = std::move(*__first); ++__result2; } std::move(__buffer, __result2, __result1); return __result1; } _ForwardIterator __middle = __first; std::advance(__middle, __len / 2); _ForwardIterator __left_split = std::__stable_partition_adaptive(__first, __middle, __pred, __len / 2, __buffer, __buffer_size); _Distance __right_len = __len - __len / 2; _ForwardIterator __right_split = std::__find_if_not_n(__middle, __right_len, __pred); if (__right_len) __right_split = std::__stable_partition_adaptive(__right_split, __last, __pred, __right_len, __buffer, __buffer_size); return std::rotate(__left_split, __middle, __right_split); } template _ForwardIterator __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { __first = std::__find_if_not(__first, __last, __pred); if (__first == __last) return __first; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType; _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, std::distance(__first, __last)); return std::__stable_partition_adaptive(__first, __last, __pred, _DistanceType(__buf.requested_size()), __buf.begin(), _DistanceType(__buf.size())); } # 1647 "/usr/include/c++/10/bits/stl_algo.h" 3 template inline _ForwardIterator stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; return std::__stable_partition(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } template 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 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; } # 1735 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _RandomAccessIterator partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last) { # 1750 "/usr/include/c++/10/bits/stl_algo.h" 3 ; ; ; return std::__partial_sort_copy(__first, __last, __result_first, __result_last, __gnu_cxx::__ops::__iter_less_iter()); } # 1785 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _RandomAccessIterator partial_sort_copy(_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp) { # 1802 "/usr/include/c++/10/bits/stl_algo.h" 3 ; ; ; return std::__partial_sort_copy(__first, __last, __result_first, __result_last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template 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 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 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 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 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 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 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 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 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 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); } # 2033 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 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; } # 2089 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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()); } # 2120 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 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); } # 2193 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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()); } # 2230 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 2264 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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); } # 2298 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 void __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) { if (__comp(__first2, __first1)) { *__result = std::move(*__first2); ++__first2; } else { *__result = std::move(*__first1); ++__first1; } ++__result; } if (__first1 != __last1) std::move(__first1, __last1, __result); } template void __move_merge_adaptive_backward(_BidirectionalIterator1 __first1, _BidirectionalIterator1 __last1, _BidirectionalIterator2 __first2, _BidirectionalIterator2 __last2, _BidirectionalIterator3 __result, _Compare __comp) { if (__first1 == __last1) { std::move_backward(__first2, __last2, __result); return; } else if (__first2 == __last2) return; --__last1; --__last2; while (true) { if (__comp(__last2, __last1)) { *--__result = std::move(*__last1); if (__first1 == __last1) { std::move_backward(__first2, ++__last2, __result); return; } --__last1; } else { *--__result = std::move(*__last2); if (__first2 == __last2) return; --__last2; } } } template _BidirectionalIterator1 __rotate_adaptive(_BidirectionalIterator1 __first, _BidirectionalIterator1 __middle, _BidirectionalIterator1 __last, _Distance __len1, _Distance __len2, _BidirectionalIterator2 __buffer, _Distance __buffer_size) { _BidirectionalIterator2 __buffer_end; if (__len1 > __len2 && __len2 <= __buffer_size) { if (__len2) { __buffer_end = std::move(__middle, __last, __buffer); std::move_backward(__first, __middle, __last); return std::move(__buffer, __buffer_end, __first); } else return __first; } else if (__len1 <= __buffer_size) { if (__len1) { __buffer_end = std::move(__first, __middle, __buffer); std::move(__middle, __last, __first); return std::move_backward(__buffer, __buffer_end, __last); } else return __last; } else return std::rotate(__first, __middle, __last); } template void __merge_adaptive(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Pointer __buffer, _Distance __buffer_size, _Compare __comp) { if (__len1 <= __len2 && __len1 <= __buffer_size) { _Pointer __buffer_end = std::move(__first, __middle, __buffer); std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last, __first, __comp); } else if (__len2 <= __buffer_size) { _Pointer __buffer_end = std::move(__middle, __last, __buffer); std::__move_merge_adaptive_backward(__first, __middle, __buffer, __buffer_end, __last, __comp); } else { _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::__lower_bound(__middle, __last, *__first_cut, __gnu_cxx::__ops::__iter_comp_val(__comp)); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::__upper_bound(__first, __middle, *__second_cut, __gnu_cxx::__ops::__val_comp_iter(__comp)); __len11 = std::distance(__first, __first_cut); } _BidirectionalIterator __new_middle = std::__rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11, __len22, __buffer, __buffer_size); std::__merge_adaptive(__first, __first_cut, __new_middle, __len11, __len22, __buffer, __buffer_size, __comp); std::__merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11, __len2 - __len22, __buffer, __buffer_size, __comp); } } template void __merge_without_buffer(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Distance __len1, _Distance __len2, _Compare __comp) { if (__len1 == 0 || __len2 == 0) return; if (__len1 + __len2 == 2) { if (__comp(__middle, __first)) std::iter_swap(__first, __middle); return; } _BidirectionalIterator __first_cut = __first; _BidirectionalIterator __second_cut = __middle; _Distance __len11 = 0; _Distance __len22 = 0; if (__len1 > __len2) { __len11 = __len1 / 2; std::advance(__first_cut, __len11); __second_cut = std::__lower_bound(__middle, __last, *__first_cut, __gnu_cxx::__ops::__iter_comp_val(__comp)); __len22 = std::distance(__middle, __second_cut); } else { __len22 = __len2 / 2; std::advance(__second_cut, __len22); __first_cut = std::__upper_bound(__first, __middle, *__second_cut, __gnu_cxx::__ops::__val_comp_iter(__comp)); __len11 = std::distance(__first, __first_cut); } _BidirectionalIterator __new_middle = std::rotate(__first_cut, __middle, __second_cut); std::__merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22, __comp); std::__merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11, __len2 - __len22, __comp); } template void __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) { typedef typename iterator_traits<_BidirectionalIterator>::value_type _ValueType; typedef typename iterator_traits<_BidirectionalIterator>::difference_type _DistanceType; if (__first == __middle || __middle == __last) return; const _DistanceType __len1 = std::distance(__first, __middle); const _DistanceType __len2 = std::distance(__middle, __last); typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf; _TmpBuf __buf(__first, __len1 + __len2); if (__buf.begin() == 0) std::__merge_without_buffer (__first, __middle, __last, __len1, __len2, __comp); else std::__merge_adaptive (__first, __middle, __last, __len1, __len2, __buf.begin(), _DistanceType(__buf.size()), __comp); } # 2588 "/usr/include/c++/10/bits/stl_algo.h" 3 template inline void inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) { ; ; ; std::__inplace_merge(__first, __middle, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 2629 "/usr/include/c++/10/bits/stl_algo.h" 3 template inline void inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) { ; ; ; std::__inplace_merge(__first, __middle, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _OutputIterator __move_merge(_InputIterator __first1, _InputIterator __last1, _InputIterator __first2, _InputIterator __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) { if (__comp(__first2, __first1)) { *__result = std::move(*__first2); ++__first2; } else { *__result = std::move(*__first1); ++__first1; } ++__result; } return std::move(__first2, __last2, std::move(__first1, __last1, __result)) ; } template void __merge_sort_loop(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator2 __result, _Distance __step_size, _Compare __comp) { const _Distance __two_step = 2 * __step_size; while (__last - __first >= __two_step) { __result = std::__move_merge(__first, __first + __step_size, __first + __step_size, __first + __two_step, __result, __comp); __first += __two_step; } __step_size = std::min(_Distance(__last - __first), __step_size); std::__move_merge(__first, __first + __step_size, __first + __step_size, __last, __result, __comp); } template 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 void __merge_sort_with_buffer(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::difference_type _Distance; const _Distance __len = __last - __first; const _Pointer __buffer_last = __buffer + __len; _Distance __step_size = _S_chunk_size; std::__chunk_insertion_sort(__first, __last, __step_size, __comp); while (__step_size < __len) { std::__merge_sort_loop(__first, __last, __buffer, __step_size, __comp); __step_size *= 2; std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp); __step_size *= 2; } } template void __stable_sort_adaptive(_RandomAccessIterator __first, _RandomAccessIterator __last, _Pointer __buffer, _Distance __buffer_size, _Compare __comp) { const _Distance __len = (__last - __first + 1) / 2; const _RandomAccessIterator __middle = __first + __len; if (__len > __buffer_size) { std::__stable_sort_adaptive(__first, __middle, __buffer, __buffer_size, __comp); std::__stable_sort_adaptive(__middle, __last, __buffer, __buffer_size, __comp); } else { std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp); std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp); } std::__merge_adaptive(__first, __middle, __last, _Distance(__middle - __first), _Distance(__last - __middle), __buffer, __buffer_size, __comp); } template 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); } # 2802 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr bool __includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) if (__comp(__first2, __first1)) return false; else if (__comp(__first1, __first2)) ++__first1; else { ++__first1; ++__first2; } return __first2 == __last2; } # 2842 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) { ; ; ; ; return std::__includes(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_less_iter()); } # 2887 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp) { ; ; ; ; return std::__includes(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 2923 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr bool __next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (__comp(__i, __ii)) { _BidirectionalIterator __j = __last; while (!__comp(__i, --__j)) {} std::iter_swap(__i, __j); std::__reverse(__ii, __last, std::__iterator_category(__first)); return true; } if (__i == __first) { std::__reverse(__first, __last, std::__iterator_category(__first)); return false; } } } # 2973 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; ; return std::__next_permutation (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 3006 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { ; ; return std::__next_permutation (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr bool __prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { if (__first == __last) return false; _BidirectionalIterator __i = __first; ++__i; if (__i == __last) return false; __i = __last; --__i; for(;;) { _BidirectionalIterator __ii = __i; --__i; if (__comp(__ii, __i)) { _BidirectionalIterator __j = __last; while (!__comp(--__j, __i)) {} std::iter_swap(__i, __j); std::__reverse(__ii, __last, std::__iterator_category(__first)); return true; } if (__i == __first) { std::__reverse(__first, __last, std::__iterator_category(__first)); return false; } } } # 3076 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) { ; ; return std::__prev_permutation(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 3109 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) { ; ; return std::__prev_permutation(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template 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; } # 3161 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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); } # 3196 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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); } # 3225 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool is_sorted(_ForwardIterator __first, _ForwardIterator __last) { return std::is_sorted_until(__first, __last) == __last; } # 3240 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline bool is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { return std::is_sorted_until(__first, __last, __comp) == __last; } template 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; } # 3271 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__is_sorted_until(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 3296 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 3322 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline pair minmax(const _Tp& __a, const _Tp& __b) { return __b < __a ? pair(__b, __a) : pair(__a, __b); } # 3343 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline pair minmax(const _Tp& __a, const _Tp& __b, _Compare __comp) { return __comp(__b, __a) ? pair(__b, __a) : pair(__a, __b); } template constexpr pair<_ForwardIterator, _ForwardIterator> __minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { _ForwardIterator __next = __first; if (__first == __last || ++__next == __last) return std::make_pair(__first, __first); _ForwardIterator __min{}, __max{}; if (__comp(__next, __first)) { __min = __next; __max = __first; } else { __min = __first; __max = __next; } __first = __next; ++__first; while (__first != __last) { __next = __first; if (++__next == __last) { if (__comp(__first, __min)) __min = __first; else if (!__comp(__first, __max)) __max = __first; break; } if (__comp(__next, __first)) { if (__comp(__next, __min)) __min = __next; if (!__comp(__first, __max)) __max = __first; } else { if (__comp(__first, __min)) __min = __first; if (!__comp(__next, __max)) __max = __next; } __first = __next; ++__first; } return std::make_pair(__min, __max); } # 3423 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__minmax_element(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 3451 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; ; return std::__minmax_element(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr inline _Tp min(initializer_list<_Tp> __l) { return *std::min_element(__l.begin(), __l.end()); } template constexpr inline _Tp min(initializer_list<_Tp> __l, _Compare __comp) { return *std::min_element(__l.begin(), __l.end(), __comp); } template constexpr inline _Tp max(initializer_list<_Tp> __l) { return *std::max_element(__l.begin(), __l.end()); } template constexpr inline _Tp max(initializer_list<_Tp> __l, _Compare __comp) { return *std::max_element(__l.begin(), __l.end(), __comp); } template constexpr inline pair<_Tp, _Tp> minmax(initializer_list<_Tp> __l) { pair __p = std::minmax_element(__l.begin(), __l.end()); return std::make_pair(*__p.first, *__p.second); } template constexpr inline pair<_Tp, _Tp> minmax(initializer_list<_Tp> __l, _Compare __comp) { pair __p = std::minmax_element(__l.begin(), __l.end(), __comp); return std::make_pair(*__p.first, *__p.second); } # 3528 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 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; } # 3623 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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()); } # 3651 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 3678 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr const _Tp& clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi) { ; return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val; } # 3696 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr const _Tp& clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp) { ; return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val; } # 3728 "/usr/include/c++/10/bits/stl_algo.h" 3 template pair<_IntType, _IntType> __gen_two_uniform_ints(_IntType __b0, _IntType __b1, _UniformRandomBitGenerator&& __g) { _IntType __x = uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g); return std::make_pair(__x / __b1, __x % __b1); } # 3750 "/usr/include/c++/10/bits/stl_algo.h" 3 template void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, _UniformRandomNumberGenerator&& __g) { ; if (__first == __last) return; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; typedef typename std::make_unsigned<_DistanceType>::type __ud_type; typedef typename std::uniform_int_distribution<__ud_type> __distr_type; typedef typename __distr_type::param_type __p_type; typedef typename remove_reference<_UniformRandomNumberGenerator>::type _Gen; typedef typename common_type::type __uc_type; const __uc_type __urngrange = __g.max() - __g.min(); const __uc_type __urange = __uc_type(__last - __first); if (__urngrange / __urange >= __urange) { _RandomAccessIterator __i = __first + 1; if ((__urange % 2) == 0) { __distr_type __d{0, 1}; std::iter_swap(__i++, __first + __d(__g)); } while (__i != __last) { const __uc_type __swap_range = __uc_type(__i - __first) + 1; const pair<__uc_type, __uc_type> __pospos = __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g); std::iter_swap(__i++, __first + __pospos.first); std::iter_swap(__i++, __first + __pospos.second); } return; } __distr_type __d; for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first))); } # 3835 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr _Function for_each(_InputIterator __first, _InputIterator __last, _Function __f) { ; for (; __first != __last; ++__first) __f(*__first); return __f; } # 3861 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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) { 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; } } # 3897 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _InputIterator find(_InputIterator __first, _InputIterator __last, const _Tp& __val) { ; return std::__find_if(__first, __last, __gnu_cxx::__ops::__iter_equals_val(__val)); } # 3922 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _InputIterator find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) { ; return std::__find_if(__first, __last, __gnu_cxx::__ops::__pred_iter(__pred)); } # 3954 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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; } # 3995 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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; } # 4028 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator adjacent_find(_ForwardIterator __first, _ForwardIterator __last) { ; return std::__adjacent_find(__first, __last, __gnu_cxx::__ops::__iter_equal_to_iter()); } # 4054 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4080 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4104 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4145 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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()); } # 4185 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4221 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4255 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4281 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator search(_ForwardIterator __first, _ForwardIterator __last, const _Searcher& __searcher) { return __searcher(__first, __last).first; } # 4305 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr _OutputIterator transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __unary_op) { ; for (; __first != __last; ++__first, (void)++__result) *__result = __unary_op(*__first); return __result; } # 4343 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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; } # 4377 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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; } # 4410 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr void replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) { ; for (; __first != __last; ++__first) if (__pred(*__first)) *__first = __new_value; } # 4443 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr void generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) { ; for (; __first != __last; ++__first) *__first = __gen(); } # 4477 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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; } # 4515 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4556 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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)); } # 4590 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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); } } # 4625 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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); } } # 4665 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { ; return std::__partition(__first, __last, __pred, std::__iterator_category(__first)); } # 4699 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline void partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) { ; ; ; std::__partial_sort(__first, __middle, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 4738 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline void partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) { ; ; ; std::__partial_sort(__first, __middle, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 4775 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) { ; ; ; if (__first == __last || __nth == __last) return; std::__introselect(__first, __nth, __last, std::__lg(__last - __first) * 2, __gnu_cxx::__ops::__iter_less_iter()); } # 4815 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) { ; ; ; if (__first == __last || __nth == __last) return; std::__introselect(__first, __nth, __last, std::__lg(__last - __first) * 2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } # 4853 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline void sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 4884 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template 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)); } # 4947 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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()); } # 4998 "/usr/include/c++/10/bits/stl_algo.h" 3 template 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 inline void __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; typedef typename iterator_traits<_RandomAccessIterator>::difference_type _DistanceType; typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf; _TmpBuf __buf(__first, std::distance(__first, __last)); if (__buf.begin() == 0) std::__inplace_stable_sort(__first, __last, __comp); else std::__stable_sort_adaptive(__first, __last, __buf.begin(), _DistanceType(__buf.size()), __comp); } # 5063 "/usr/include/c++/10/bits/stl_algo.h" 3 template inline void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { ; ; std::__stable_sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 5097 "/usr/include/c++/10/bits/stl_algo.h" 3 template inline void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { ; ; std::__stable_sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template 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)); } # 5167 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_union(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5218 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_union(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_union(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr _OutputIterator __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) if (__comp(__first1, __first2)) ++__first1; else if (__comp(__first2, __first1)) ++__first2; else { *__result = *__first1; ++__first1; ++__first2; ++__result; } return __result; } # 5291 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_intersection(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5341 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_intersection(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr _OutputIterator __set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) if (__comp(__first1, __first2)) { *__result = *__first1; ++__first1; ++__result; } else if (__comp(__first2, __first1)) ++__first2; else { ++__first1; ++__first2; } return std::copy(__first1, __last1, __result); } # 5416 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5468 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr _OutputIterator __set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { while (__first1 != __last1 && __first2 != __last2) if (__comp(__first1, __first2)) { *__result = *__first1; ++__first1; ++__result; } else if (__comp(__first2, __first1)) { *__result = *__first2; ++__first2; ++__result; } else { ++__first1; ++__first2; } return std::copy(__first2, __last2, std::copy(__first1, __last1, __result)); } # 5549 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result) { ; ; ; ; return std::__set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_less_iter()); } # 5601 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _OutputIterator set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp) { ; ; ; ; return std::__set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr _ForwardIterator __min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (__comp(__first, __result)) __result = __first; return __result; } # 5655 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr _ForwardIterator inline min_element(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__min_element(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 5680 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; ; return std::__min_element(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template constexpr _ForwardIterator __max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { if (__first == __last) return __first; _ForwardIterator __result = __first; while (++__first != __last) if (__comp(__result, __first)) __result = __first; return __result; } # 5719 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last) { ; ; return std::__max_element(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); } # 5744 "/usr/include/c++/10/bits/stl_algo.h" 3 template constexpr inline _ForwardIterator max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { ; ; return std::__max_element(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); } template _RandomAccessIterator __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag, _RandomAccessIterator __out, random_access_iterator_tag, _Size __n, _UniformRandomBitGenerator&& __g) { using __distrib_type = uniform_int_distribution<_Size>; using __param_type = typename __distrib_type::param_type; __distrib_type __d{}; _Size __sample_sz = 0; while (__first != __last && __sample_sz != __n) { __out[__sample_sz++] = *__first; ++__first; } for (auto __pop_sz = __sample_sz; __first != __last; ++__first, (void) ++__pop_sz) { const auto __k = __d(__g, __param_type{0, __pop_sz}); if (__k < __n) __out[__k] = *__first; } return __out + __sample_sz; } template _OutputIterator __sample(_ForwardIterator __first, _ForwardIterator __last, forward_iterator_tag, _OutputIterator __out, _Cat, _Size __n, _UniformRandomBitGenerator&& __g) { using __distrib_type = uniform_int_distribution<_Size>; using __param_type = typename __distrib_type::param_type; using _USize = make_unsigned_t<_Size>; using _Gen = remove_reference_t<_UniformRandomBitGenerator>; using __uc_type = common_type_t; if (__first == __last) return __out; __distrib_type __d{}; _Size __unsampled_sz = std::distance(__first, __last); __n = std::min(__n, __unsampled_sz); const __uc_type __urngrange = __g.max() - __g.min(); if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz)) { while (__n != 0 && __unsampled_sz >= 2) { const pair<_Size, _Size> __p = __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g); --__unsampled_sz; if (__p.first < __n) { *__out++ = *__first; --__n; } ++__first; if (__n == 0) break; --__unsampled_sz; if (__p.second < __n) { *__out++ = *__first; --__n; } ++__first; } } for (; __n != 0; ++__first) if (__d(__g, __param_type{0, --__unsampled_sz}) < __n) { *__out++ = *__first; --__n; } return __out; } template _SampleIterator sample(_PopulationIterator __first, _PopulationIterator __last, _SampleIterator __out, _Distance __n, _UniformRandomBitGenerator&& __g) { using __pop_cat = typename std::iterator_traits<_PopulationIterator>::iterator_category; using __samp_cat = typename std::iterator_traits<_SampleIterator>::iterator_category; static_assert( __or_, is_convertible<__samp_cat, random_access_iterator_tag>>::value, "output range must use a RandomAccessIterator when input range" " does not meet the ForwardIterator requirements"); static_assert(is_integral<_Distance>::value, "sample size must be an integer type"); typename iterator_traits<_PopulationIterator>::difference_type __d = __n; return std:: __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d, std::forward<_UniformRandomBitGenerator>(__g)); } } # 53 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/range_access.h" 1 3 # 33 "/usr/include/c++/10/bits/range_access.h" 3 # 34 "/usr/include/c++/10/bits/range_access.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template inline constexpr auto begin(_Container& __cont) -> decltype(__cont.begin()) { return __cont.begin(); } template inline constexpr auto begin(const _Container& __cont) -> decltype(__cont.begin()) { return __cont.begin(); } template inline constexpr auto end(_Container& __cont) -> decltype(__cont.end()) { return __cont.end(); } template inline constexpr auto end(const _Container& __cont) -> decltype(__cont.end()) { return __cont.end(); } template inline constexpr _Tp* begin(_Tp (&__arr)[_Nm]) noexcept { return __arr; } template inline constexpr _Tp* end(_Tp (&__arr)[_Nm]) noexcept { return __arr + _Nm; } template class valarray; template _Tp* begin(valarray<_Tp>&); template const _Tp* begin(const valarray<_Tp>&); template _Tp* end(valarray<_Tp>&); template const _Tp* end(const valarray<_Tp>&); template inline constexpr auto cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont)) { return std::begin(__cont); } template inline constexpr auto cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont)) { return std::end(__cont); } template inline constexpr auto rbegin(_Container& __cont) -> decltype(__cont.rbegin()) { return __cont.rbegin(); } template inline constexpr auto rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) { return __cont.rbegin(); } template inline constexpr auto rend(_Container& __cont) -> decltype(__cont.rend()) { return __cont.rend(); } template inline constexpr auto rend(const _Container& __cont) -> decltype(__cont.rend()) { return __cont.rend(); } template inline constexpr reverse_iterator<_Tp*> rbegin(_Tp (&__arr)[_Nm]) noexcept { return reverse_iterator<_Tp*>(__arr + _Nm); } template inline constexpr reverse_iterator<_Tp*> rend(_Tp (&__arr)[_Nm]) noexcept { return reverse_iterator<_Tp*>(__arr); } template inline constexpr reverse_iterator rbegin(initializer_list<_Tp> __il) noexcept { return reverse_iterator(__il.end()); } template inline constexpr reverse_iterator rend(initializer_list<_Tp> __il) noexcept { return reverse_iterator(__il.begin()); } template inline constexpr auto crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) { return std::rbegin(__cont); } template inline constexpr auto crend(const _Container& __cont) -> decltype(std::rend(__cont)) { return std::rend(__cont); } # 243 "/usr/include/c++/10/bits/range_access.h" 3 template constexpr auto size(const _Container& __cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size()) { return __cont.size(); } template constexpr size_t size(const _Tp (&)[_Nm]) noexcept { return _Nm; } template [[nodiscard]] constexpr auto empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty()) { return __cont.empty(); } template [[nodiscard]] constexpr bool empty(const _Tp (&)[_Nm]) noexcept { return false; } template [[nodiscard]] constexpr bool empty(initializer_list<_Tp> __il) noexcept { return __il.size() == 0;} template constexpr auto data(_Container& __cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data()) { return __cont.data(); } template constexpr auto data(const _Container& __cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data()) { return __cont.data(); } template constexpr _Tp* data(_Tp (&__array)[_Nm]) noexcept { return __array; } template constexpr const _Tp* data(initializer_list<_Tp> __il) noexcept { return __il.begin(); } template constexpr auto ssize(const _Container& __cont) noexcept(noexcept(__cont.size())) -> common_type_t> { using type = make_signed_t; return static_cast>(__cont.size()); } template constexpr ptrdiff_t ssize(const _Tp (&)[_Num]) noexcept { return _Num; } namespace ranges { template inline constexpr bool disable_sized_range = false; template inline constexpr bool enable_borrowed_range = false; template extern const bool enable_view; namespace __detail { template constexpr auto __to_unsigned_like(_Tp __t) noexcept { return static_cast>(__t); } constexpr unsigned __int128 __to_unsigned_like(__int128 __t) noexcept { return __t; } constexpr unsigned __int128 __to_unsigned_like(unsigned __int128 __t) noexcept { return __t; } template using __make_unsigned_like_t = decltype(__detail::__to_unsigned_like(std::declval<_Tp>())); template concept __maybe_borrowed_range = is_lvalue_reference_v<_Tp> || enable_borrowed_range>; } namespace __cust_access { using std::ranges::__detail::__maybe_borrowed_range; using std::__detail::__class_or_enum; using std::__detail::__decay_copy; using std::__detail::__member_begin; using std::__detail::__adl_begin; struct _Begin { private: template static constexpr bool _S_noexcept() { if constexpr (is_array_v>) 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> || __member_begin<_Tp> || __adl_begin<_Tp> constexpr auto operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>()) { if constexpr (is_array_v>) { static_assert(is_lvalue_reference_v<_Tp>); using _Up = remove_all_extents_t>; static_assert(sizeof(_Up) != 0, "not array of incomplete type"); return __t + 0; } else if constexpr (__member_begin<_Tp>) return __t.begin(); else return begin(__t); } }; template concept __member_end = requires(_Tp& __t) { { __decay_copy(__t.end()) } -> sentinel_for(__t)))>; }; void end(auto&) = delete; void end(const auto&) = delete; template concept __adl_end = __class_or_enum> && requires(_Tp& __t) { { __decay_copy(end(__t)) } -> sentinel_for(__t)))>; }; struct _End { private: template static constexpr bool _S_noexcept() { if constexpr (is_bounded_array_v>) 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> || __member_end<_Tp> || __adl_end<_Tp> constexpr auto operator()(_Tp&& __t) const noexcept(_S_noexcept<_Tp>()) { if constexpr (is_bounded_array_v>) { static_assert(is_lvalue_reference_v<_Tp>); return __t + extent_v>; } else if constexpr (__member_end<_Tp>) return __t.end(); else return end(__t); } }; template constexpr decltype(auto) __as_const(_Tp&& __t) noexcept { if constexpr (is_lvalue_reference_v<_Tp>) return static_cast&>(__t); else return static_cast(__t); } struct _CBegin { template constexpr auto operator()(_Tp&& __e) const noexcept(noexcept(_Begin{}(__cust_access::__as_const((_Tp&&)__e)))) requires requires { _Begin{}(__cust_access::__as_const((_Tp&&)__e)); } { return _Begin{}(__cust_access::__as_const(std::forward<_Tp>(__e))); } }; struct _CEnd { template constexpr auto operator()(_Tp&& __e) const noexcept(noexcept(_End{}(__cust_access::__as_const((_Tp&&)__e)))) requires requires { _End{}(__cust_access::__as_const((_Tp&&)__e)); } { return _End{}(__cust_access::__as_const(std::forward<_Tp>(__e))); } }; template concept __member_rbegin = requires(_Tp& __t) { { __decay_copy(__t.rbegin()) } -> input_or_output_iterator; }; void rbegin(auto&) = delete; void rbegin(const auto&) = delete; template concept __adl_rbegin = __class_or_enum> && requires(_Tp& __t) { { __decay_copy(rbegin(__t)) } -> input_or_output_iterator; }; template concept __reversable = requires(_Tp& __t) { { _Begin{}(__t) } -> bidirectional_iterator; { _End{}(__t) } -> same_as; }; struct _RBegin { private: template 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()(_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 concept __member_rend = requires(_Tp& __t) { { __decay_copy(__t.rend()) } -> sentinel_for; }; void rend(auto&) = delete; void rend(const auto&) = delete; template concept __adl_rend = __class_or_enum> && requires(_Tp& __t) { { __decay_copy(rend(__t)) } -> sentinel_for(__t)))>; }; struct _REnd { private: template 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()(_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)); } }; struct _CRBegin { template constexpr auto operator()(_Tp&& __e) const noexcept(noexcept(_RBegin{}(__cust_access::__as_const((_Tp&&)__e)))) requires requires { _RBegin{}(__cust_access::__as_const((_Tp&&)__e)); } { return _RBegin{}(__cust_access::__as_const(std::forward<_Tp>(__e))); } }; struct _CREnd { template constexpr auto operator()(_Tp&& __e) const noexcept(noexcept(_REnd{}(__cust_access::__as_const((_Tp&&)__e)))) requires requires { _REnd{}(__cust_access::__as_const((_Tp&&)__e)); } { return _REnd{}(__cust_access::__as_const(std::forward<_Tp>(__e))); } }; template concept __member_size = !disable_sized_range> && requires(_Tp&& __t) { { __decay_copy(std::forward<_Tp>(__t).size()) } -> __detail::__is_integer_like; }; void size(auto&) = delete; void size(const auto&) = delete; template concept __adl_size = __class_or_enum> && !disable_sized_range> && requires(_Tp&& __t) { { __decay_copy(size(std::forward<_Tp>(__t))) } -> __detail::__is_integer_like; }; template concept __sentinel_size = requires(_Tp&& __t) { { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator; { _End{}(std::forward<_Tp>(__t)) } -> sized_sentinel_for(__t)))>; }; struct _Size { private: template static constexpr bool _S_noexcept() { if constexpr (is_bounded_array_v>) 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 requires is_bounded_array_v> || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp> constexpr auto operator()(_Tp&& __e) const noexcept(_S_noexcept<_Tp>()) { if constexpr (is_bounded_array_v>) { return extent_v>; } else if constexpr (__member_size<_Tp>) return std::forward<_Tp>(__e).size(); else if constexpr (__adl_size<_Tp>) return size(std::forward<_Tp>(__e)); else if constexpr (__sentinel_size<_Tp>) return __detail::__to_unsigned_like( _End{}(std::forward<_Tp>(__e)) - _Begin{}(std::forward<_Tp>(__e))); } }; struct _SSize { template requires requires (_Tp&& __e) { _Begin{}(std::forward<_Tp>(__e)); _Size{}(std::forward<_Tp>(__e)); } constexpr auto operator()(_Tp&& __e) const noexcept(noexcept(_Size{}(std::forward<_Tp>(__e)))) { using __iter_type = decltype(_Begin{}(std::forward<_Tp>(__e))); using __diff_type = iter_difference_t<__iter_type>; using __gnu_cxx::__int_traits; auto __size = _Size{}(std::forward<_Tp>(__e)); if constexpr (integral<__diff_type>) { if constexpr (__int_traits<__diff_type>::__digits < __int_traits::__digits) return static_cast(__size); } return static_cast<__diff_type>(__size); } }; template concept __member_empty = requires(_Tp&& __t) { bool(std::forward<_Tp>(__t).empty()); }; template concept __size0_empty = requires(_Tp&& __t) { _Size{}(std::forward<_Tp>(__t)) == 0; }; template concept __eq_iter_empty = requires(_Tp&& __t) { { _Begin{}(std::forward<_Tp>(__t)) } -> forward_iterator; bool(_Begin{}(std::forward<_Tp>(__t)) == _End{}(std::forward<_Tp>(__t))); }; struct _Empty { private: template static constexpr bool _S_noexcept() { if constexpr (__member_empty<_Tp>) return noexcept(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 requires __member_empty<_Tp> || __size0_empty<_Tp> || __eq_iter_empty<_Tp> constexpr bool operator()(_Tp&& __e) const noexcept(_S_noexcept<_Tp>()) { if constexpr (__member_empty<_Tp>) return bool(std::forward<_Tp>(__e).empty()); else if constexpr (__size0_empty<_Tp>) return _Size{}(std::forward<_Tp>(__e)) == 0; else return bool(_Begin{}(std::forward<_Tp>(__e)) == _End{}(std::forward<_Tp>(__e))); } }; template concept __pointer_to_object = is_pointer_v<_Tp> && is_object_v>; template concept __member_data = is_lvalue_reference_v<_Tp> && requires(_Tp __t) { { __t.data() } -> __pointer_to_object; }; template concept __begin_data = requires(_Tp&& __t) { { _Begin{}(std::forward<_Tp>(__t)) } -> contiguous_iterator; }; struct _Data { private: template 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()(_Tp&& __e) const noexcept(_S_noexcept<_Tp>()) { if constexpr (__member_data<_Tp>) return __e.data(); else return std::to_address(_Begin{}(std::forward<_Tp>(__e))); } }; struct _CData { template constexpr auto operator()(_Tp&& __e) const noexcept(noexcept(_Data{}(__cust_access::__as_const((_Tp&&)__e)))) requires requires { _Data{}(__cust_access::__as_const((_Tp&&)__e)); } { return _Data{}(__cust_access::__as_const(std::forward<_Tp>(__e))); } }; } inline namespace __cust { inline constexpr __cust_access::_Begin begin{}; inline constexpr __cust_access::_End end{}; inline constexpr __cust_access::_CBegin cbegin{}; inline constexpr __cust_access::_CEnd cend{}; inline constexpr __cust_access::_RBegin rbegin{}; inline constexpr __cust_access::_REnd rend{}; inline constexpr __cust_access::_CRBegin crbegin{}; inline constexpr __cust_access::_CREnd crend{}; inline constexpr __cust_access::_Size size{}; inline constexpr __cust_access::_SSize ssize{}; inline constexpr __cust_access::_Empty empty{}; inline constexpr __cust_access::_Data data{}; inline constexpr __cust_access::_CData cdata{}; } template concept range = requires(_Tp& __t) { ranges::begin(__t); ranges::end(__t); }; template concept borrowed_range = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>; template using iterator_t = std::__detail::__range_iter_t<_Tp>; template using sentinel_t = decltype(ranges::end(std::declval<_Range&>())); template using range_difference_t = iter_difference_t>; template using range_value_t = iter_value_t>; template using range_reference_t = iter_reference_t>; template using range_rvalue_reference_t = iter_rvalue_reference_t>; template concept sized_range = range<_Tp> && requires(_Tp& __t) { ranges::size(__t); }; template using range_size_t = decltype(ranges::size(std::declval<_Range&>())); template concept output_range = range<_Range> && output_iterator, _Tp>; template concept input_range = range<_Tp> && input_iterator>; template concept forward_range = input_range<_Tp> && forward_iterator>; template concept bidirectional_range = forward_range<_Tp> && bidirectional_iterator>; template concept random_access_range = bidirectional_range<_Tp> && random_access_iterator>; template concept contiguous_range = random_access_range<_Tp> && contiguous_iterator> && requires(_Tp& __t) { { ranges::data(__t) } -> same_as>>; }; template concept common_range = range<_Tp> && same_as, sentinel_t<_Tp>>; template constexpr void advance(_It& __it, iter_difference_t<_It> __n) { 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 { if (std::is_constant_evaluated() && __n < 0) throw "attempt to decrement a non-bidirectional iterator"; ; while (__n-- > 0) ++__it; } } template _Sent> constexpr void advance(_It& __it, _Sent __bound) { if constexpr (assignable_from<_It&, _Sent>) __it = std::move(__bound); else if constexpr (sized_sentinel_for<_Sent, _It>) ranges::advance(__it, __bound - __it); else { while (__it != __bound) ++__it; } } template _Sent> constexpr iter_difference_t<_It> advance(_It& __it, iter_difference_t<_It> __n, _Sent __bound) { if constexpr (sized_sentinel_for<_Sent, _It>) { const auto __diff = __bound - __it; if (std::is_constant_evaluated() && !(__n == 0 || __diff == 0 || (__n < 0 == __diff < 0))) throw "inconsistent directions for distance and bound"; ; const auto __absdiff = __diff < 0 ? -__diff : __diff; const auto __absn = __n < 0 ? -__n : __n;; if (__absn >= __absdiff) { ranges::advance(__it, __bound); return __n - __diff; } else { ranges::advance(__it, __n); return 0; } } else if (__it == __bound || __n == 0) return iter_difference_t<_It>(0); 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 { if (std::is_constant_evaluated() && __n < 0) throw "attempt to decrement a non-bidirectional iterator"; ; return __n; } } template _Sent> constexpr iter_difference_t<_It> distance(_It __first, _Sent __last) { if constexpr (sized_sentinel_for<_Sent, _It>) return __last - __first; else { iter_difference_t<_It> __n = 0; while (__first != __last) { ++__first; ++__n; } return __n; } } template constexpr range_difference_t<_Range> distance(_Range&& __r) { if constexpr (sized_range<_Range>) return static_cast>(ranges::size(__r)); else return ranges::distance(ranges::begin(__r), ranges::end(__r)); } template constexpr _It next(_It __x) { ++__x; return __x; } template constexpr _It next(_It __x, iter_difference_t<_It> __n) { ranges::advance(__x, __n); return __x; } template _Sent> constexpr _It next(_It __x, _Sent __bound) { ranges::advance(__x, __bound); return __x; } template _Sent> constexpr _It next(_It __x, iter_difference_t<_It> __n, _Sent __bound) { ranges::advance(__x, __n, __bound); return __x; } template constexpr _It prev(_It __x) { --__x; return __x; } template constexpr _It prev(_It __x, iter_difference_t<_It> __n) { ranges::advance(__x, -__n); return __x; } template constexpr _It prev(_It __x, iter_difference_t<_It> __n, _It __bound) { ranges::advance(__x, -__n, __bound); return __x; } } } # 55 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/basic_string.h" 1 3 # 37 "/usr/include/c++/10/bits/basic_string.h" 3 # 38 "/usr/include/c++/10/bits/basic_string.h" 3 # 1 "/usr/include/c++/10/ext/atomicity.h" 1 3 # 32 "/usr/include/c++/10/ext/atomicity.h" 3 # 33 "/usr/include/c++/10/ext/atomicity.h" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr.h" 1 3 # 30 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr.h" 3 #pragma GCC visibility push(default) # 148 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr.h" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 1 3 # 35 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 # 1 "/usr/include/pthread.h" 1 3 4 # 22 "/usr/include/pthread.h" 3 4 # 1 "/usr/include/sched.h" 1 3 4 # 29 "/usr/include/sched.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 30 "/usr/include/sched.h" 2 3 4 # 43 "/usr/include/sched.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/sched.h" 1 3 4 # 76 "/usr/include/x86_64-linux-gnu/bits/sched.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h" 1 3 4 # 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h" 3 4 struct sched_param { int sched_priority; }; # 77 "/usr/include/x86_64-linux-gnu/bits/sched.h" 2 3 4 extern "C" { extern int clone (int (*__fn) (void *__arg), void *__child_stack, int __flags, void *__arg, ...) throw (); extern int unshare (int __flags) throw (); extern int sched_getcpu (void) throw (); extern int getcpu (unsigned int *, unsigned int *) throw (); extern int setns (int __fd, int __nstype) throw (); } # 44 "/usr/include/sched.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 1 3 4 # 32 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 3 4 typedef unsigned long int __cpu_mask; typedef struct { __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; } cpu_set_t; # 115 "/usr/include/x86_64-linux-gnu/bits/cpu-set.h" 3 4 extern "C" { extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) throw (); extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ; extern void __sched_cpufree (cpu_set_t *__set) throw (); } # 45 "/usr/include/sched.h" 2 3 4 extern "C" { extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) throw (); extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw (); extern int sched_setscheduler (__pid_t __pid, int __policy, const struct sched_param *__param) throw (); extern int sched_getscheduler (__pid_t __pid) throw (); extern int sched_yield (void) throw (); extern int sched_get_priority_max (int __algorithm) throw (); extern int sched_get_priority_min (int __algorithm) throw (); extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw (); # 121 "/usr/include/sched.h" 3 4 extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, const cpu_set_t *__cpuset) throw (); extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, cpu_set_t *__cpuset) throw (); } # 23 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/time.h" 1 3 4 # 29 "/usr/include/time.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 30 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4 # 73 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/timex.h" 1 3 4 # 26 "/usr/include/x86_64-linux-gnu/bits/timex.h" 3 4 struct timex { unsigned int modes; __syscall_slong_t offset; __syscall_slong_t freq; __syscall_slong_t maxerror; __syscall_slong_t esterror; int status; __syscall_slong_t constant; __syscall_slong_t precision; __syscall_slong_t tolerance; struct timeval time; __syscall_slong_t tick; __syscall_slong_t ppsfreq; __syscall_slong_t jitter; int shift; __syscall_slong_t stabil; __syscall_slong_t jitcnt; __syscall_slong_t calcnt; __syscall_slong_t errcnt; __syscall_slong_t stbcnt; int tai; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; }; # 74 "/usr/include/x86_64-linux-gnu/bits/time.h" 2 3 4 extern "C" { extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw (); } # 34 "/usr/include/time.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4 struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; long int tm_gmtoff; const char *tm_zone; }; # 40 "/usr/include/time.h" 2 3 4 # 48 "/usr/include/time.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4 struct itimerspec { struct timespec it_interval; struct timespec it_value; }; # 49 "/usr/include/time.h" 2 3 4 struct sigevent; # 68 "/usr/include/time.h" 3 4 extern "C" { extern clock_t clock (void) throw (); extern time_t time (time_t *__timer) throw (); extern double difftime (time_t __time1, time_t __time0) throw () __attribute__ ((__const__)); extern time_t mktime (struct tm *__tp) throw (); extern size_t strftime (char *__restrict __s, size_t __maxsize, const char *__restrict __format, const struct tm *__restrict __tp) throw (); extern char *strptime (const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp) throw (); extern size_t strftime_l (char *__restrict __s, size_t __maxsize, const char *__restrict __format, const struct tm *__restrict __tp, locale_t __loc) throw (); extern char *strptime_l (const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp, locale_t __loc) throw (); extern struct tm *gmtime (const time_t *__timer) throw (); extern struct tm *localtime (const time_t *__timer) throw (); extern struct tm *gmtime_r (const time_t *__restrict __timer, struct tm *__restrict __tp) throw (); extern struct tm *localtime_r (const time_t *__restrict __timer, struct tm *__restrict __tp) throw (); extern char *asctime (const struct tm *__tp) throw (); extern char *ctime (const time_t *__timer) throw (); extern char *asctime_r (const struct tm *__restrict __tp, char *__restrict __buf) throw (); extern char *ctime_r (const time_t *__restrict __timer, char *__restrict __buf) throw (); extern char *__tzname[2]; extern int __daylight; extern long int __timezone; extern char *tzname[2]; extern void tzset (void) throw (); extern int daylight; extern long int timezone; # 190 "/usr/include/time.h" 3 4 extern time_t timegm (struct tm *__tp) throw (); extern time_t timelocal (struct tm *__tp) throw (); extern int dysize (int __year) throw () __attribute__ ((__const__)); # 205 "/usr/include/time.h" 3 4 extern int nanosleep (const struct timespec *__requested_time, struct timespec *__remaining); extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw (); extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw (); extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) throw (); extern int clock_nanosleep (clockid_t __clock_id, int __flags, const struct timespec *__req, struct timespec *__rem); extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw (); extern int timer_create (clockid_t __clock_id, struct sigevent *__restrict __evp, timer_t *__restrict __timerid) throw (); extern int timer_delete (timer_t __timerid) throw (); extern int timer_settime (timer_t __timerid, int __flags, const struct itimerspec *__restrict __value, struct itimerspec *__restrict __ovalue) throw (); extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) throw (); extern int timer_getoverrun (timer_t __timerid) throw (); extern int timespec_get (struct timespec *__ts, int __base) throw () __attribute__ ((__nonnull__ (1))); # 274 "/usr/include/time.h" 3 4 extern int getdate_err; # 283 "/usr/include/time.h" 3 4 extern struct tm *getdate (const char *__string); # 297 "/usr/include/time.h" 3 4 extern int getdate_r (const char *__restrict __string, struct tm *__restrict __resbufp); } # 24 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 1 3 4 # 26 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/setjmp.h" 2 3 4 typedef long int __jmp_buf[8]; # 28 "/usr/include/pthread.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 29 "/usr/include/pthread.h" 2 3 4 enum { PTHREAD_CREATE_JOINABLE, PTHREAD_CREATE_DETACHED }; enum { PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_ADAPTIVE_NP , PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP }; enum { PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_ROBUST, PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST }; enum { PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, PTHREAD_PRIO_PROTECT }; # 100 "/usr/include/pthread.h" 3 4 enum { PTHREAD_RWLOCK_PREFER_READER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP }; # 120 "/usr/include/pthread.h" 3 4 enum { PTHREAD_INHERIT_SCHED, PTHREAD_EXPLICIT_SCHED }; enum { PTHREAD_SCOPE_SYSTEM, PTHREAD_SCOPE_PROCESS }; enum { PTHREAD_PROCESS_PRIVATE, PTHREAD_PROCESS_SHARED }; # 155 "/usr/include/pthread.h" 3 4 struct _pthread_cleanup_buffer { void (*__routine) (void *); void *__arg; int __canceltype; struct _pthread_cleanup_buffer *__prev; }; enum { PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DISABLE }; enum { PTHREAD_CANCEL_DEFERRED, PTHREAD_CANCEL_ASYNCHRONOUS }; # 193 "/usr/include/pthread.h" 3 4 extern "C" { extern int pthread_create (pthread_t *__restrict __newthread, const pthread_attr_t *__restrict __attr, void *(*__start_routine) (void *), void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3))); extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); extern int pthread_join (pthread_t __th, void **__thread_return); extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw (); extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, const struct timespec *__abstime); # 238 "/usr/include/pthread.h" 3 4 extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, clockid_t __clockid, const struct timespec *__abstime); extern int pthread_detach (pthread_t __th) throw (); extern pthread_t pthread_self (void) throw () __attribute__ ((__const__)); extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw () __attribute__ ((__const__)); extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_destroy (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, int *__detachstate) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, int __detachstate) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, size_t *__guardsize) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setguardsize (pthread_attr_t *__attr, size_t __guardsize) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, struct sched_param *__restrict __param) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, const struct sched_param *__restrict __param) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict __attr, int *__restrict __policy) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict __attr, int *__restrict __inherit) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, int __inherit) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, int *__restrict __scope) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict __attr, void **__restrict __stackaddr) throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, void *__stackaddr) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict __attr, size_t *__restrict __stacksize) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_attr_setstacksize (pthread_attr_t *__attr, size_t __stacksize) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, void **__restrict __stackaddr, size_t *__restrict __stacksize) throw () __attribute__ ((__nonnull__ (1, 2, 3))); extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, size_t __stacksize) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, size_t __cpusetsize, const cpu_set_t *__cpuset) throw () __attribute__ ((__nonnull__ (1, 3))); extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, size_t __cpusetsize, cpu_set_t *__cpuset) throw () __attribute__ ((__nonnull__ (1, 3))); extern int pthread_getattr_default_np (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_setattr_default_np (const pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (2))); extern int pthread_setschedparam (pthread_t __target_thread, int __policy, const struct sched_param *__param) throw () __attribute__ ((__nonnull__ (3))); extern int pthread_getschedparam (pthread_t __target_thread, int *__restrict __policy, struct sched_param *__restrict __param) throw () __attribute__ ((__nonnull__ (2, 3))); extern int pthread_setschedprio (pthread_t __target_thread, int __prio) throw (); extern int pthread_getname_np (pthread_t __target_thread, char *__buf, size_t __buflen) throw () __attribute__ ((__nonnull__ (2))); extern int pthread_setname_np (pthread_t __target_thread, const char *__name) throw () __attribute__ ((__nonnull__ (2))); extern int pthread_getconcurrency (void) throw (); extern int pthread_setconcurrency (int __level) throw (); extern int pthread_yield (void) throw (); extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, const cpu_set_t *__cpuset) throw () __attribute__ ((__nonnull__ (3))); extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, cpu_set_t *__cpuset) throw () __attribute__ ((__nonnull__ (3))); # 470 "/usr/include/pthread.h" 3 4 extern int pthread_once (pthread_once_t *__once_control, void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); # 482 "/usr/include/pthread.h" 3 4 extern int pthread_setcancelstate (int __state, int *__oldstate); extern int pthread_setcanceltype (int __type, int *__oldtype); extern int pthread_cancel (pthread_t __th); extern void pthread_testcancel (void); typedef struct { struct { __jmp_buf __cancel_jmp_buf; int __mask_was_saved; } __cancel_jmp_buf[1]; void *__pad[4]; } __pthread_unwind_buf_t __attribute__ ((__aligned__)); # 516 "/usr/include/pthread.h" 3 4 struct __pthread_cleanup_frame { void (*__cancel_routine) (void *); void *__cancel_arg; int __do_it; int __cancel_type; }; class __pthread_cleanup_class { void (*__cancel_routine) (void *); void *__cancel_arg; int __do_it; int __cancel_type; public: __pthread_cleanup_class (void (*__fct) (void *), void *__arg) : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } void __setdoit (int __newval) { __do_it = __newval; } void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &__cancel_type); } void __restore () const { pthread_setcanceltype (__cancel_type, 0); } }; # 718 "/usr/include/pthread.h" 3 4 struct __jmp_buf_tag; extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw (); extern int pthread_mutex_init (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_lock (pthread_mutex_t *__mutex) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, const struct timespec *__restrict __abstime) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, clockid_t __clockid, const struct timespec *__restrict __abstime) throw () __attribute__ ((__nonnull__ (1, 3))); extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_getprioceiling (const pthread_mutex_t * __restrict __mutex, int *__restrict __prioceiling) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, int __prioceiling, int *__restrict __old_ceiling) throw () __attribute__ ((__nonnull__ (1, 3))); extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex) throw () __attribute__ ((__nonnull__ (1))); # 789 "/usr/include/pthread.h" 3 4 extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * __restrict __attr, int *__restrict __pshared) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, int __pshared) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict __attr, int *__restrict __kind) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * __restrict __attr, int *__restrict __protocol) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, int __protocol) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * __restrict __attr, int *__restrict __prioceiling) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, int __prioceiling) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, int *__robustness) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr, int *__robustness) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, int __robustness) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr, int __robustness) throw () __attribute__ ((__nonnull__ (1))); # 871 "/usr/include/pthread.h" 3 4 extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, const pthread_rwlockattr_t *__restrict __attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, const struct timespec *__restrict __abstime) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, clockid_t __clockid, const struct timespec *__restrict __abstime) throw () __attribute__ ((__nonnull__ (1, 3))); extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, const struct timespec *__restrict __abstime) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, clockid_t __clockid, const struct timespec *__restrict __abstime) throw () __attribute__ ((__nonnull__ (1, 3))); extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * __restrict __attr, int *__restrict __pshared) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, int __pshared) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * __restrict __attr, int *__restrict __pref) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, int __pref) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_cond_init (pthread_cond_t *__restrict __cond, const pthread_condattr_t *__restrict __cond_attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_cond_destroy (pthread_cond_t *__cond) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_cond_signal (pthread_cond_t *__cond) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_cond_broadcast (pthread_cond_t *__cond) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex) __attribute__ ((__nonnull__ (1, 2))); # 997 "/usr/include/pthread.h" 3 4 extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex, const struct timespec *__restrict __abstime) __attribute__ ((__nonnull__ (1, 2, 3))); # 1010 "/usr/include/pthread.h" 3 4 extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex, __clockid_t __clock_id, const struct timespec *__restrict __abstime) __attribute__ ((__nonnull__ (1, 2, 4))); extern int pthread_condattr_init (pthread_condattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_condattr_destroy (pthread_condattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_condattr_getpshared (const pthread_condattr_t * __restrict __attr, int *__restrict __pshared) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, int __pshared) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_condattr_getclock (const pthread_condattr_t * __restrict __attr, __clockid_t *__restrict __clock_id) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_condattr_setclock (pthread_condattr_t *__attr, __clockid_t __clock_id) throw () __attribute__ ((__nonnull__ (1))); # 1056 "/usr/include/pthread.h" 3 4 extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_spin_destroy (pthread_spinlock_t *__lock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_spin_lock (pthread_spinlock_t *__lock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_spin_trylock (pthread_spinlock_t *__lock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_spin_unlock (pthread_spinlock_t *__lock) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, const pthread_barrierattr_t *__restrict __attr, unsigned int __count) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_barrier_wait (pthread_barrier_t *__barrier) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * __restrict __attr, int *__restrict __pshared) throw () __attribute__ ((__nonnull__ (1, 2))); extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, int __pshared) throw () __attribute__ ((__nonnull__ (1))); # 1123 "/usr/include/pthread.h" 3 4 extern int pthread_key_create (pthread_key_t *__key, void (*__destr_function) (void *)) throw () __attribute__ ((__nonnull__ (1))); extern int pthread_key_delete (pthread_key_t __key) throw (); extern void *pthread_getspecific (pthread_key_t __key) throw (); extern int pthread_setspecific (pthread_key_t __key, const void *__pointer) throw () ; extern int pthread_getcpuclockid (pthread_t __thread_id, __clockid_t *__clock_id) throw () __attribute__ ((__nonnull__ (2))); # 1157 "/usr/include/pthread.h" 3 4 extern int pthread_atfork (void (*__prepare) (void), void (*__parent) (void), void (*__child) (void)) throw (); # 1171 "/usr/include/pthread.h" 3 4 } # 36 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 2 3 # 47 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 typedef pthread_t __gthread_t; typedef pthread_key_t __gthread_key_t; typedef pthread_once_t __gthread_once_t; typedef pthread_mutex_t __gthread_mutex_t; typedef pthread_mutex_t __gthread_recursive_mutex_t; typedef pthread_cond_t __gthread_cond_t; typedef struct timespec __gthread_time_t; # 102 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once"), __copy__ (pthread_once))); static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific"), __copy__ (pthread_getspecific))); static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific"), __copy__ (pthread_setspecific))); static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create"), __copy__ (pthread_create))); static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join"), __copy__ (pthread_join))); static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal"), __copy__ (pthread_equal))); static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self"), __copy__ (pthread_self))); static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach"), __copy__ (pthread_detach))); static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel"), __copy__ (pthread_cancel))); static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield"), __copy__ (sched_yield))); static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock"), __copy__ (pthread_mutex_lock))); static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock"), __copy__ (pthread_mutex_trylock))); static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock"), __copy__ (pthread_mutex_timedlock))); static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock"), __copy__ (pthread_mutex_unlock))); static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init"), __copy__ (pthread_mutex_init))); static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy"), __copy__ (pthread_mutex_destroy))); static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init"), __copy__ (pthread_cond_init))); static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast"), __copy__ (pthread_cond_broadcast))); static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal"), __copy__ (pthread_cond_signal))); static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait"), __copy__ (pthread_cond_wait))); static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait"), __copy__ (pthread_cond_timedwait))); static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy"), __copy__ (pthread_cond_destroy))); static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create"), __copy__ (pthread_key_create))); static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete"), __copy__ (pthread_key_delete))); static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init"), __copy__ (pthread_mutexattr_init))); static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype"), __copy__ (pthread_mutexattr_settype))); static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy"), __copy__ (pthread_mutexattr_destroy))); # 237 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create"), __copy__ (pthread_key_create))); # 247 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 static inline int __gthread_active_p (void) { static void *const __gthread_active_ptr = __extension__ (void *) &__gthrw___pthread_key_create; return __gthread_active_ptr != 0; } # 659 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 static inline int __gthread_create (__gthread_t *__threadid, void *(*__func) (void*), void *__args) { return __gthrw_pthread_create (__threadid, __null, __func, __args); } static inline int __gthread_join (__gthread_t __threadid, void **__value_ptr) { return __gthrw_pthread_join (__threadid, __value_ptr); } static inline int __gthread_detach (__gthread_t __threadid) { return __gthrw_pthread_detach (__threadid); } static inline int __gthread_equal (__gthread_t __t1, __gthread_t __t2) { return __gthrw_pthread_equal (__t1, __t2); } static inline __gthread_t __gthread_self (void) { return __gthrw_pthread_self (); } static inline int __gthread_yield (void) { return __gthrw_sched_yield (); } static inline int __gthread_once (__gthread_once_t *__once, void (*__func) (void)) { if (__gthread_active_p ()) return __gthrw_pthread_once (__once, __func); else return -1; } static inline int __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) { return __gthrw_pthread_key_create (__key, __dtor); } static inline int __gthread_key_delete (__gthread_key_t __key) { return __gthrw_pthread_key_delete (__key); } static inline void * __gthread_getspecific (__gthread_key_t __key) { return __gthrw_pthread_getspecific (__key); } static inline int __gthread_setspecific (__gthread_key_t __key, const void *__ptr) { return __gthrw_pthread_setspecific (__key, __ptr); } static inline void __gthread_mutex_init_function (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) __gthrw_pthread_mutex_init (__mutex, __null); } static inline int __gthread_mutex_destroy (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_destroy (__mutex); else return 0; } static inline int __gthread_mutex_lock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_lock (__mutex); else return 0; } static inline int __gthread_mutex_trylock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_trylock (__mutex); else return 0; } static inline int __gthread_mutex_timedlock (__gthread_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout); else return 0; } static inline int __gthread_mutex_unlock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_unlock (__mutex); else return 0; } # 808 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_lock (__mutex); } static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_trylock (__mutex); } static inline int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { return __gthread_mutex_timedlock (__mutex, __abs_timeout); } static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_unlock (__mutex); } static inline int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_destroy (__mutex); } # 850 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr-default.h" 3 static inline int __gthread_cond_broadcast (__gthread_cond_t *__cond) { return __gthrw_pthread_cond_broadcast (__cond); } static inline int __gthread_cond_signal (__gthread_cond_t *__cond) { return __gthrw_pthread_cond_signal (__cond); } static inline int __gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) { return __gthrw_pthread_cond_wait (__cond, __mutex); } static inline int __gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout); } static inline int __gthread_cond_wait_recursive (__gthread_cond_t *__cond, __gthread_recursive_mutex_t *__mutex) { return __gthread_cond_wait (__cond, __mutex); } static inline int __gthread_cond_destroy (__gthread_cond_t* __cond) { return __gthrw_pthread_cond_destroy (__cond); } # 149 "/usr/include/x86_64-linux-gnu/c++/10/bits/gthr.h" 2 3 #pragma GCC visibility pop # 36 "/usr/include/c++/10/ext/atomicity.h" 2 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/atomic_word.h" 1 3 # 32 "/usr/include/x86_64-linux-gnu/c++/10/bits/atomic_word.h" 3 typedef int _Atomic_word; # 37 "/usr/include/c++/10/ext/atomicity.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { inline _Atomic_word __attribute__((__always_inline__)) __exchange_and_add(volatile _Atomic_word* __mem, int __val) { return __atomic_fetch_add(__mem, __val, 4); } inline void __attribute__((__always_inline__)) __atomic_add(volatile _Atomic_word* __mem, int __val) { __atomic_fetch_add(__mem, __val, 4); } # 64 "/usr/include/c++/10/ext/atomicity.h" 3 inline _Atomic_word __attribute__((__always_inline__)) __exchange_and_add_single(_Atomic_word* __mem, int __val) { _Atomic_word __result = *__mem; *__mem += __val; return __result; } inline void __attribute__((__always_inline__)) __atomic_add_single(_Atomic_word* __mem, int __val) { *__mem += __val; } inline _Atomic_word __attribute__ ((__always_inline__)) __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) { if (__gthread_active_p()) return __exchange_and_add(__mem, __val); return __exchange_and_add_single(__mem, __val); } inline void __attribute__ ((__always_inline__)) __atomic_add_dispatch(_Atomic_word* __mem, int __val) { if (__gthread_active_p()) { __atomic_add(__mem, __val); return; } __atomic_add_single(__mem, __val); } } # 40 "/usr/include/c++/10/bits/basic_string.h" 2 3 # 1 "/usr/include/c++/10/ext/alloc_traits.h" 1 3 # 32 "/usr/include/c++/10/ext/alloc_traits.h" 3 # 33 "/usr/include/c++/10/ext/alloc_traits.h" 3 # 1 "/usr/include/c++/10/bits/alloc_traits.h" 1 3 # 41 "/usr/include/c++/10/bits/alloc_traits.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct __allocator_traits_base { template struct __rebind : __replace_first_arg<_Tp, _Up> { }; template struct __rebind<_Tp, _Up, __void_t::other>> { using type = typename _Tp::template rebind<_Up>::other; }; protected: template using __pointer = typename _Tp::pointer; template using __c_pointer = typename _Tp::const_pointer; template using __v_pointer = typename _Tp::void_pointer; template using __cv_pointer = typename _Tp::const_void_pointer; template using __pocca = typename _Tp::propagate_on_container_copy_assignment; template using __pocma = typename _Tp::propagate_on_container_move_assignment; template using __pocs = typename _Tp::propagate_on_container_swap; template using __equal = typename _Tp::is_always_equal; }; template using __alloc_rebind = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; template struct allocator_traits : __allocator_traits_base { typedef _Alloc allocator_type; typedef typename _Alloc::value_type value_type; using pointer = __detected_or_t; private: template class _Func, typename _Tp, typename = void> struct _Ptr { using type = typename pointer_traits::template rebind<_Tp>; }; template class _Func, typename _Tp> struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> { using type = _Func<_Alloc>; }; template struct _Diff { using type = typename pointer_traits<_PtrT>::difference_type; }; template struct _Diff<_A2, _PtrT, __void_t> { using type = typename _A2::difference_type; }; template struct _Size : make_unsigned<_DiffT> { }; template struct _Size<_A2, _DiffT, __void_t> { 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; using propagate_on_container_move_assignment = __detected_or_t; using propagate_on_container_swap = __detected_or_t; using is_always_equal = __detected_or_t::type, __equal, _Alloc>; template using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; template using rebind_traits = allocator_traits>; private: template 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 static constexpr pointer _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) { return __a.allocate(__n); } template struct __construct_helper { template()->construct( std::declval<_Tp*>(), std::declval<_Args>()...))> static true_type __test(int); template static false_type __test(...); using type = decltype(__test<_Alloc>(0)); }; template using __has_construct = typename __construct_helper<_Tp, _Args...>::type; template 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 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 static constexpr auto _S_destroy(_Alloc2& __a, _Tp* __p, int) noexcept(noexcept(__a.destroy(__p))) -> decltype(__a.destroy(__p)) { __a.destroy(__p); } template static constexpr void _S_destroy(_Alloc2&, _Tp* __p, ...) noexcept(std::is_nothrow_destructible<_Tp>::value) { std::_Destroy(__p); } template static constexpr auto _S_max_size(_Alloc2& __a, int) -> decltype(__a.max_size()) { return __a.max_size(); } template static constexpr size_type _S_max_size(_Alloc2&, ...) { return __gnu_cxx::__numeric_traits::__max / sizeof(value_type); } template static constexpr auto _S_select(_Alloc2& __a, int) -> decltype(__a.select_on_container_copy_construction()) { return __a.select_on_container_copy_construction(); } template static constexpr _Alloc2 _S_select(_Alloc2& __a, ...) { return __a; } public: # 312 "/usr/include/c++/10/bits/alloc_traits.h" 3 [[__nodiscard__]] static constexpr pointer allocate(_Alloc& __a, size_type __n) { return __a.allocate(__n); } # 327 "/usr/include/c++/10/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); } # 339 "/usr/include/c++/10/bits/alloc_traits.h" 3 static constexpr void deallocate(_Alloc& __a, pointer __p, size_type __n) { __a.deallocate(__p, __n); } # 354 "/usr/include/c++/10/bits/alloc_traits.h" 3 template 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)...); } # 370 "/usr/include/c++/10/bits/alloc_traits.h" 3 template static constexpr void destroy(_Alloc& __a, _Tp* __p) noexcept(noexcept(_S_destroy(__a, __p, 0))) { _S_destroy(__a, __p, 0); } # 384 "/usr/include/c++/10/bits/alloc_traits.h" 3 static constexpr size_type max_size(const _Alloc& __a) noexcept { return _S_max_size(__a, 0); } # 396 "/usr/include/c++/10/bits/alloc_traits.h" 3 static constexpr _Alloc select_on_container_copy_construction(const _Alloc& __rhs) { return _S_select(__rhs, 0); } }; template struct allocator_traits> { 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 using rebind_alloc = allocator<_Up>; template using rebind_traits = allocator_traits>; # 458 "/usr/include/c++/10/bits/alloc_traits.h" 3 [[__nodiscard__]] static constexpr pointer allocate(allocator_type& __a, size_type __n) { return __a.allocate(__n); } # 472 "/usr/include/c++/10/bits/alloc_traits.h" 3 [[__nodiscard__]] static constexpr pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) { return __a.allocate(__n); } # 490 "/usr/include/c++/10/bits/alloc_traits.h" 3 static constexpr void deallocate(allocator_type& __a, pointer __p, size_type __n) { __a.deallocate(__p, __n); } # 505 "/usr/include/c++/10/bits/alloc_traits.h" 3 template 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)...); } # 525 "/usr/include/c++/10/bits/alloc_traits.h" 3 template static constexpr void destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) noexcept(is_nothrow_destructible<_Up>::value) { std::destroy_at(__p); } static constexpr size_type max_size(const allocator_type& __a __attribute__((__unused__))) noexcept { return size_t(-1) / sizeof(value_type); } static constexpr allocator_type select_on_container_copy_construction(const allocator_type& __rhs) { return __rhs; } }; # 574 "/usr/include/c++/10/bits/alloc_traits.h" 3 template constexpr inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two) { typedef allocator_traits<_Alloc> __traits; typedef typename __traits::propagate_on_container_copy_assignment __pocca; if constexpr (__pocca::value) __one = __two; } template constexpr _Alloc __alloc_on_copy(const _Alloc& __a) { typedef allocator_traits<_Alloc> __traits; return __traits::select_on_container_copy_construction(__a); } # 606 "/usr/include/c++/10/bits/alloc_traits.h" 3 template constexpr inline void __alloc_on_move(_Alloc& __one, _Alloc& __two) { typedef allocator_traits<_Alloc> __traits; typedef typename __traits::propagate_on_container_move_assignment __pocma; if constexpr (__pocma::value) __one = std::move(__two); } # 633 "/usr/include/c++/10/bits/alloc_traits.h" 3 template constexpr inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two) { typedef allocator_traits<_Alloc> __traits; typedef typename __traits::propagate_on_container_swap __pocs; if constexpr (__pocs::value) { using std::swap; swap(__one, __two); } } template, typename = void> struct __is_alloc_insertable_impl : false_type { }; template struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, __void_t::construct( std::declval<_Alloc&>(), std::declval<_ValueT*>(), std::declval<_Tp>()))>> : true_type { }; template struct __is_copy_insertable : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type const&>::type { }; template struct __is_copy_insertable> : is_copy_constructible<_Tp> { }; template struct __is_move_insertable : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type { }; template struct __is_move_insertable> : is_move_constructible<_Tp> { }; template struct __is_allocator : false_type { }; template struct __is_allocator<_Alloc, __void_t().allocate(size_t{}))>> : true_type { }; template using _RequireAllocator = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; template using _RequireNotAllocator = typename enable_if::value, _Alloc>::type; # 719 "/usr/include/c++/10/bits/alloc_traits.h" 3 template void _Destroy(_ForwardIterator __first, _ForwardIterator __last, _Allocator& __alloc) { for (; __first != __last; ++__first) allocator_traits<_Allocator>::destroy(__alloc, std::__addressof(*__first)); } template inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last, allocator<_Tp>&) { _Destroy(__first, __last); } } # 35 "/usr/include/c++/10/ext/alloc_traits.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { template 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 using __is_custom_pointer = std::__and_, std::__not_>>; public: template 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 static constexpr std::__enable_if_t<__is_custom_pointer<_Ptr>::value> destroy(_Alloc& __a, _Ptr __p) noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) { _Base_type::destroy(__a, std::__to_address(__p)); } static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) { return _Base_type::select_on_container_copy_construction(__a); } static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) { std::__alloc_on_swap(__a, __b); } static constexpr bool _S_propagate_on_copy_assign() { return _Base_type::propagate_on_container_copy_assignment::value; } static constexpr bool _S_propagate_on_move_assign() { return _Base_type::propagate_on_container_move_assignment::value; } static constexpr bool _S_propagate_on_swap() { return _Base_type::propagate_on_container_swap::value; } static constexpr bool _S_always_equal() { return _Base_type::is_always_equal::value; } static constexpr bool _S_nothrow_move() { return _S_propagate_on_move_assign() || _S_always_equal(); } template struct rebind { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; # 166 "/usr/include/c++/10/ext/alloc_traits.h" 3 }; } # 41 "/usr/include/c++/10/bits/basic_string.h" 2 3 # 1 "/usr/include/c++/10/string_view" 1 3 # 36 "/usr/include/c++/10/string_view" 3 # 37 "/usr/include/c++/10/string_view" 3 # 1 "/usr/include/c++/10/bits/functional_hash.h" 1 3 # 33 "/usr/include/c++/10/bits/functional_hash.h" 3 # 34 "/usr/include/c++/10/bits/functional_hash.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 49 "/usr/include/c++/10/bits/functional_hash.h" 3 template struct __hash_base { typedef _Result result_type [[__deprecated__]]; typedef _Arg argument_type [[__deprecated__]]; }; template struct hash; template struct __poison_hash { static constexpr bool __enable_hash_call = false; private: __poison_hash(__poison_hash&&); ~__poison_hash(); }; template struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> { static constexpr bool __enable_hash_call = true; }; template::value> struct __hash_enum { private: __hash_enum(__hash_enum&&); ~__hash_enum(); }; template struct __hash_enum<_Tp, true> : public __hash_base { size_t operator()(_Tp __val) const noexcept { using __type = typename underlying_type<_Tp>::type; return hash<__type>{}(static_cast<__type>(__val)); } }; template struct hash : __hash_enum<_Tp> { }; template struct hash<_Tp*> : public __hash_base { size_t operator()(_Tp* __p) const noexcept { return reinterpret_cast(__p); } }; # 124 "/usr/include/c++/10/bits/functional_hash.h" 3 template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(char8_t __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; # 192 "/usr/include/c++/10/bits/functional_hash.h" 3 struct _Hash_impl { static size_t hash(const void* __ptr, size_t __clength, size_t __seed = static_cast(0xc70f6907UL)) { return _Hash_bytes(__ptr, __clength, __seed); } template static size_t hash(const _Tp& __val) { return hash(&__val, sizeof(__val)); } template 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(2166136261UL)) { return _Fnv_hash_bytes(__ptr, __clength, __seed); } template static size_t hash(const _Tp& __val) { return hash(&__val, sizeof(__val)); } template static size_t __hash_combine(const _Tp& __val, size_t __hash) { return hash(&__val, sizeof(__val), __hash); } }; template<> struct hash : public __hash_base { size_t operator()(float __val) const noexcept { return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; } }; template<> struct hash : public __hash_base { size_t operator()(double __val) const noexcept { return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; } }; template<> struct hash : public __hash_base { __attribute__ ((__pure__)) size_t operator()(long double __val) const noexcept; }; template<> struct hash : public __hash_base { size_t operator()(nullptr_t) const noexcept { return 0; } }; # 278 "/usr/include/c++/10/bits/functional_hash.h" 3 template struct __is_fast_hash : public std::true_type { }; template<> struct __is_fast_hash> : public std::false_type { }; } # 43 "/usr/include/c++/10/string_view" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { constexpr size_t __sv_check(size_t __size, size_t __pos, const char* __s) { if (__pos > __size) __throw_out_of_range_fmt(("%s: __pos (which is %zu) > __size " "(which is %zu)") , __s, __pos, __size); return __pos; } constexpr size_t __sv_limit(size_t __size, size_t __pos, size_t __off) noexcept { const bool __testoff = __off < __size - __pos; return __testoff ? __off : __size - __pos; } # 93 "/usr/include/c++/10/string_view" 3 template> 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; using reverse_iterator = const_reverse_iterator; using size_type = size_t; using difference_type = ptrdiff_t; static constexpr size_type npos = size_type(-1); constexpr basic_string_view() noexcept : _M_len{0}, _M_str{nullptr} { } constexpr basic_string_view(const basic_string_view&) noexcept = default; __attribute__((__nonnull__)) constexpr basic_string_view(const _CharT* __str) noexcept : _M_len{traits_type::length(__str)}, _M_str{__str} { } constexpr basic_string_view(const _CharT* __str, size_type __len) noexcept : _M_len{__len}, _M_str{__str} { } template _End> requires same_as, _CharT> && (!convertible_to<_End, size_type>) constexpr basic_string_view(_It __first, _End __last) : _M_len(__last - __first), _M_str(std::to_address(__first)) { } constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default; constexpr const_iterator begin() const noexcept { return this->_M_str; } constexpr const_iterator end() const noexcept { return this->_M_str + this->_M_len; } constexpr const_iterator cbegin() const noexcept { return this->_M_str; } constexpr const_iterator cend() const noexcept { return this->_M_str + this->_M_len; } constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(this->end()); } constexpr const_reverse_iterator rend() const noexcept { return const_reverse_iterator(this->begin()); } constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->end()); } constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->begin()); } constexpr size_type size() const noexcept { return this->_M_len; } constexpr size_type length() const noexcept { return _M_len; } constexpr size_type max_size() const noexcept { return (npos - sizeof(size_type) - sizeof(void*)) / sizeof(value_type) / 4; } [[nodiscard]] constexpr bool empty() const noexcept { return this->_M_len == 0; } constexpr const_reference operator[](size_type __pos) const noexcept { ; return *(this->_M_str + __pos); } constexpr const_reference at(size_type __pos) const { if (__pos >= _M_len) __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)") , __pos, this->size()); return *(this->_M_str + __pos); } constexpr const_reference front() const noexcept { ; return *this->_M_str; } constexpr const_reference back() const noexcept { ; return *(this->_M_str + this->_M_len - 1); } constexpr const_pointer data() const noexcept { return this->_M_str; } constexpr void remove_prefix(size_type __n) noexcept { ; this->_M_str += __n; this->_M_len -= __n; } constexpr void remove_suffix(size_type __n) noexcept { this->_M_len -= __n; } constexpr void swap(basic_string_view& __sv) noexcept { auto __tmp = *this; *this = __sv; __sv = __tmp; } 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(__n, _M_len - __pos); traits_type::copy(__str, data() + __pos, __rlen); return __rlen; } constexpr basic_string_view substr(size_type __pos = 0, size_type __n = npos) const noexcept(false) { __pos = std::__sv_check(size(), __pos, "basic_string_view::substr"); const size_type __rlen = std::min(__n, _M_len - __pos); return basic_string_view{_M_str + __pos, __rlen}; } constexpr int compare(basic_string_view __str) const noexcept { const size_type __rlen = std::min(this->_M_len, __str._M_len); int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen); if (__ret == 0) __ret = _S_compare(this->_M_len, __str._M_len); return __ret; } constexpr int compare(size_type __pos1, size_type __n1, basic_string_view __str) const { return this->substr(__pos1, __n1).compare(__str); } constexpr int compare(size_type __pos1, size_type __n1, basic_string_view __str, size_type __pos2, size_type __n2) const { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); } __attribute__((__nonnull__)) constexpr int compare(const _CharT* __str) const noexcept { return this->compare(basic_string_view{__str}); } __attribute__((__nonnull__)) constexpr int compare(size_type __pos1, size_type __n1, const _CharT* __str) const { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); } constexpr int compare(size_type __pos1, size_type __n1, const _CharT* __str, size_type __n2) const noexcept(false) { return this->substr(__pos1, __n1) .compare(basic_string_view(__str, __n2)); } constexpr bool starts_with(basic_string_view __x) const noexcept { return this->substr(0, __x.size()) == __x; } constexpr bool starts_with(_CharT __x) const noexcept { return !this->empty() && traits_type::eq(this->front(), __x); } constexpr bool starts_with(const _CharT* __x) const noexcept { return this->starts_with(basic_string_view(__x)); } constexpr bool ends_with(basic_string_view __x) const noexcept { return this->size() >= __x.size() && this->compare(this->size() - __x.size(), npos, __x) == 0; } constexpr bool ends_with(_CharT __x) const noexcept { return !this->empty() && traits_type::eq(this->back(), __x); } constexpr bool ends_with(const _CharT* __x) const noexcept { return this->ends_with(basic_string_view(__x)); } constexpr size_type find(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find(__str._M_str, __pos, __str._M_len); } constexpr size_type find(_CharT __c, size_type __pos = 0) const noexcept; constexpr size_type find(const _CharT* __str, size_type __pos, size_type __n) const noexcept; __attribute__((__nonnull__)) constexpr size_type find(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find(__str, __pos, traits_type::length(__str)); } constexpr size_type rfind(basic_string_view __str, size_type __pos = npos) const noexcept { return this->rfind(__str._M_str, __pos, __str._M_len); } constexpr size_type rfind(_CharT __c, size_type __pos = npos) const noexcept; constexpr size_type rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept; __attribute__((__nonnull__)) constexpr size_type rfind(const _CharT* __str, size_type __pos = npos) const noexcept { return this->rfind(__str, __pos, traits_type::length(__str)); } constexpr size_type find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_first_of(_CharT __c, size_type __pos = 0) const noexcept { return this->find(__c, __pos); } constexpr size_type find_first_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; __attribute__((__nonnull__)) constexpr size_type find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str, __pos, traits_type::length(__str)); } constexpr size_type find_last_of(basic_string_view __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_last_of(_CharT __c, size_type __pos=npos) const noexcept { return this->rfind(__c, __pos); } constexpr size_type find_last_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; __attribute__((__nonnull__)) constexpr size_type find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str, __pos, traits_type::length(__str)); } constexpr size_type find_first_not_of(basic_string_view __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; constexpr size_type find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; __attribute__((__nonnull__)) constexpr size_type find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str, __pos, traits_type::length(__str)); } constexpr size_type find_last_not_of(basic_string_view __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); } constexpr size_type find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; constexpr size_type find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept; __attribute__((__nonnull__)) constexpr size_type find_last_not_of(const _CharT* __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str, __pos, traits_type::length(__str)); } private: static constexpr int _S_compare(size_type __n1, size_type __n2) noexcept { const difference_type __diff = __n1 - __n2; if (__diff > __gnu_cxx::__int_traits::__max) return __gnu_cxx::__int_traits::__max; if (__diff < __gnu_cxx::__int_traits::__min) return __gnu_cxx::__int_traits::__min; return static_cast(__diff); } size_t _M_len; const _CharT* _M_str; }; template _End> basic_string_view(_It, _End) -> basic_string_view>; # 485 "/usr/include/c++/10/string_view" 3 template constexpr bool operator==(basic_string_view<_CharT, _Traits> __x, basic_string_view<_CharT, _Traits> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template constexpr bool operator==(basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept { return __x.size() == __y.size() && __x.compare(__y) == 0; } template constexpr auto operator<=>(basic_string_view<_CharT, _Traits> __x, 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)); } template constexpr auto operator<=>(basic_string_view<_CharT, _Traits> __x, __type_identity_t> __y) noexcept -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0)) { return __detail::__char_traits_cmp_cat<_Traits>(__x.compare(__y)); } # 617 "/usr/include/c++/10/string_view" 3 template 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; using wstring_view = basic_string_view; using u8string_view = basic_string_view; using u16string_view = basic_string_view; using u32string_view = basic_string_view; template struct hash; template<> struct hash : public __hash_base { size_t operator()(const string_view& __str) const noexcept { return std::_Hash_impl::hash(__str.data(), __str.length()); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { 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> : std::false_type { }; template<> struct hash : public __hash_base { size_t operator()(const u8string_view& __str) const noexcept { return std::_Hash_impl::hash(__str.data(), __str.length()); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { 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> : std::false_type { }; template<> struct hash : public __hash_base { 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> : 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 operator""sv(const char* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } inline constexpr basic_string_view operator""sv(const wchar_t* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } inline constexpr basic_string_view operator""sv(const char8_t* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } inline constexpr basic_string_view operator""sv(const char16_t* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } inline constexpr basic_string_view operator""sv(const char32_t* __str, size_t __len) noexcept { return basic_string_view{__str, __len}; } #pragma GCC diagnostic pop } } namespace ranges { template inline constexpr bool enable_borrowed_range> = true; template inline constexpr bool enable_view> = true; } } # 1 "/usr/include/c++/10/bits/string_view.tcc" 1 3 # 37 "/usr/include/c++/10/bits/string_view.tcc" 3 # 38 "/usr/include/c++/10/bits/string_view.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template constexpr typename basic_string_view<_CharT, _Traits>::size_type basic_string_view<_CharT, _Traits>:: find(const _CharT* __str, size_type __pos, size_type __n) const noexcept { ; if (__n == 0) return __pos <= this->_M_len ? __pos : npos; if (__n <= this->_M_len) { for (; __pos <= this->_M_len - __n; ++__pos) if (traits_type::eq(this->_M_str[__pos], __str[0]) && traits_type::compare(this->_M_str + __pos + 1, __str + 1, __n - 1) == 0) return __pos; } return npos; } template 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 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 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 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 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 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 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 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 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; } } # 765 "/usr/include/c++/10/string_view" 2 3 # 49 "/usr/include/c++/10/bits/basic_string.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { # 76 "/usr/include/c++/10/bits/basic_string.h" 3 template class basic_string { typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_CharT>::other _Char_alloc_type; typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; public: typedef _Traits traits_type; typedef typename _Traits::char_type value_type; typedef _Char_alloc_type allocator_type; typedef typename _Alloc_traits::size_type size_type; typedef typename _Alloc_traits::difference_type difference_type; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef __gnu_cxx::__normal_iterator iterator; typedef __gnu_cxx::__normal_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; static const size_type npos = static_cast(-1); protected: typedef const_iterator __const_iterator; private: typedef basic_string_view<_CharT, _Traits> __sv_type; template using _If_sv = enable_if_t< __and_, __not_>, __not_>>::value, _Res>; static __sv_type _S_to_string_view(__sv_type __svt) noexcept { return __svt; } struct __sv_wrapper { explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { } __sv_type _M_sv; }; explicit basic_string(__sv_wrapper __svw, const _Alloc& __a) : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { } struct _Alloc_hider : allocator_type { _Alloc_hider(pointer __dat, const _Alloc& __a) : allocator_type(__a), _M_p(__dat) { } _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc()) : allocator_type(std::move(__a)), _M_p(__dat) { } pointer _M_p; }; _Alloc_hider _M_dataplus; size_type _M_string_length; enum { _S_local_capacity = 15 / sizeof(_CharT) }; union { _CharT _M_local_buf[_S_local_capacity + 1]; size_type _M_allocated_capacity; }; void _M_data(pointer __p) { _M_dataplus._M_p = __p; } void _M_length(size_type __length) { _M_string_length = __length; } pointer _M_data() const { return _M_dataplus._M_p; } pointer _M_local_data() { return std::pointer_traits::pointer_to(*_M_local_buf); } const_pointer _M_local_data() const { return std::pointer_traits::pointer_to(*_M_local_buf); } void _M_capacity(size_type __capacity) { _M_allocated_capacity = __capacity; } void _M_set_length(size_type __n) { _M_length(__n); traits_type::assign(_M_data()[__n], _CharT()); } bool _M_is_local() const { return _M_data() == _M_local_data(); } pointer _M_create(size_type&, size_type); void _M_dispose() { if (!_M_is_local()) _M_destroy(_M_allocated_capacity); } void _M_destroy(size_type __size) throw() { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); } template void _M_construct_aux(_InIterator __beg, _InIterator __end, std::__false_type) { typedef typename iterator_traits<_InIterator>::iterator_category _Tag; _M_construct(__beg, __end, _Tag()); } template void _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type) { _M_construct_aux_2(static_cast(__beg), __end); } void _M_construct_aux_2(size_type __req, _CharT __c) { _M_construct(__req, __c); } template void _M_construct(_InIterator __beg, _InIterator __end) { typedef typename std::__is_integer<_InIterator>::__type _Integral; _M_construct_aux(__beg, __end, _Integral()); } template void _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag); template void _M_construct(_FwdIterator __beg, _FwdIterator __end, std::forward_iterator_tag); void _M_construct(size_type __req, _CharT __c); allocator_type& _M_get_allocator() { return _M_dataplus; } const allocator_type& _M_get_allocator() const { return _M_dataplus; } private: # 309 "/usr/include/c++/10/bits/basic_string.h" 3 size_type _M_check(size_type __pos, const char* __s) const { if (__pos > this->size()) __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)") , __s, __pos, this->size()); return __pos; } void _M_check_length(size_type __n1, size_type __n2, const char* __s) const { if (this->max_size() - (this->size() - __n1) < __n2) __throw_length_error((__s)); } size_type _M_limit(size_type __pos, size_type __off) const noexcept { const bool __testoff = __off < this->size() - __pos; return __testoff ? __off : this->size() - __pos; } bool _M_disjunct(const _CharT* __s) const noexcept { return (less()(__s, _M_data()) || less()(_M_data() + this->size(), __s)); } static void _S_copy(_CharT* __d, const _CharT* __s, size_type __n) { if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::copy(__d, __s, __n); } static void _S_move(_CharT* __d, const _CharT* __s, size_type __n) { if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::move(__d, __s, __n); } static void _S_assign(_CharT* __d, size_type __n, _CharT __c) { if (__n == 1) traits_type::assign(*__d, __c); else traits_type::assign(__d, __n, __c); } template static void _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) { for (; __k1 != __k2; ++__k1, (void)++__p) traits_type::assign(*__p, *__k1); } static void _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept { _S_copy_chars(__p, __k1.base(), __k2.base()); } static void _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) noexcept { _S_copy_chars(__p, __k1.base(), __k2.base()); } static void _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept { _S_copy(__p, __k1, __k2 - __k1); } static void _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) noexcept { _S_copy(__p, __k1, __k2 - __k1); } static int _S_compare(size_type __n1, size_type __n2) noexcept { const difference_type __d = difference_type(__n1 - __n2); if (__d > __gnu_cxx::__numeric_traits::__max) return __gnu_cxx::__numeric_traits::__max; else if (__d < __gnu_cxx::__numeric_traits::__min) return __gnu_cxx::__numeric_traits::__min; else return int(__d); } void _M_assign(const basic_string&); void _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, size_type __len2); void _M_erase(size_type __pos, size_type __n); public: basic_string() noexcept(is_nothrow_default_constructible<_Alloc>::value) : _M_dataplus(_M_local_data()) { _M_set_length(0); } explicit basic_string(const _Alloc& __a) noexcept : _M_dataplus(_M_local_data(), __a) { _M_set_length(0); } basic_string(const basic_string& __str) : _M_dataplus(_M_local_data(), _Alloc_traits::_S_select_on_copy(__str._M_get_allocator())) { _M_construct(__str._M_data(), __str._M_data() + __str.length()); } # 461 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string(const basic_string& __str, size_type __pos, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { const _CharT* __start = __str._M_data() + __str._M_check(__pos, "basic_string::basic_string"); _M_construct(__start, __start + __str._M_limit(__pos, npos)); } basic_string(const basic_string& __str, size_type __pos, size_type __n) : _M_dataplus(_M_local_data()) { const _CharT* __start = __str._M_data() + __str._M_check(__pos, "basic_string::basic_string"); _M_construct(__start, __start + __str._M_limit(__pos, __n)); } # 492 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string(const basic_string& __str, size_type __pos, size_type __n, const _Alloc& __a) : _M_dataplus(_M_local_data(), __a) { const _CharT* __start = __str._M_data() + __str._M_check(__pos, "string::string"); _M_construct(__start, __start + __str._M_limit(__pos, __n)); } # 510 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string(const _CharT* __s, size_type __n, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { _M_construct(__s, __s + __n); } # 523 "/usr/include/c++/10/bits/basic_string.h" 3 template> basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); } # 538 "/usr/include/c++/10/bits/basic_string.h" 3 template> basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { _M_construct(__n, __c); } # 552 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string(basic_string&& __str) noexcept : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator())) { if (__str._M_is_local()) { traits_type::copy(_M_local_buf, __str._M_local_buf, _S_local_capacity + 1); } else { _M_data(__str._M_data()); _M_capacity(__str._M_allocated_capacity); } _M_length(__str.length()); __str._M_data(__str._M_local_data()); __str._M_set_length(0); } basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { _M_construct(__l.begin(), __l.end()); } basic_string(const basic_string& __str, const _Alloc& __a) : _M_dataplus(_M_local_data(), __a) { _M_construct(__str.begin(), __str.end()); } basic_string(basic_string&& __str, const _Alloc& __a) noexcept(_Alloc_traits::_S_always_equal()) : _M_dataplus(_M_local_data(), __a) { if (__str._M_is_local()) { traits_type::copy(_M_local_buf, __str._M_local_buf, _S_local_capacity + 1); _M_length(__str.length()); __str._M_set_length(0); } else if (_Alloc_traits::_S_always_equal() || __str.get_allocator() == __a) { _M_data(__str._M_data()); _M_length(__str.length()); _M_capacity(__str._M_allocated_capacity); __str._M_data(__str._M_local_buf); __str._M_set_length(0); } else _M_construct(__str.begin(), __str.end()); } # 620 "/usr/include/c++/10/bits/basic_string.h" 3 template> basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a = _Alloc()) : _M_dataplus(_M_local_data(), __a) { _M_construct(__beg, __end); } # 638 "/usr/include/c++/10/bits/basic_string.h" 3 template> 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> explicit basic_string(const _Tp& __t, const _Alloc& __a = _Alloc()) : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { } ~basic_string() { _M_dispose(); } basic_string& operator=(const basic_string& __str) { return this->assign(__str); } basic_string& operator=(const _CharT* __s) { return this->assign(__s); } # 685 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& operator=(_CharT __c) { this->assign(1, __c); return *this; } # 702 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& operator=(basic_string&& __str) noexcept(_Alloc_traits::_S_nothrow_move()) { if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign() && !_Alloc_traits::_S_always_equal() && _M_get_allocator() != __str._M_get_allocator()) { _M_destroy(_M_allocated_capacity); _M_data(_M_local_data()); _M_set_length(0); } std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator()); if (__str._M_is_local()) { if (__str.size()) this->_S_copy(_M_data(), __str._M_data(), __str.size()); _M_set_length(__str.size()); } else if (_Alloc_traits::_S_propagate_on_move_assign() || _Alloc_traits::_S_always_equal() || _M_get_allocator() == __str._M_get_allocator()) { pointer __data = nullptr; size_type __capacity; if (!_M_is_local()) { if (_Alloc_traits::_S_always_equal()) { __data = _M_data(); __capacity = _M_allocated_capacity; } else _M_destroy(_M_allocated_capacity); } _M_data(__str._M_data()); _M_length(__str.length()); _M_capacity(__str._M_allocated_capacity); if (__data) { __str._M_data(__data); __str._M_capacity(__capacity); } else __str._M_data(__str._M_local_buf); } else assign(__str); __str.clear(); return *this; } basic_string& operator=(initializer_list<_CharT> __l) { this->assign(__l.begin(), __l.size()); return *this; } template _If_sv<_Tp, basic_string&> operator=(const _Tp& __svt) { return this->assign(__svt); } operator __sv_type() const noexcept { return __sv_type(data(), size()); } iterator begin() noexcept { return iterator(_M_data()); } const_iterator begin() const noexcept { return const_iterator(_M_data()); } iterator end() noexcept { return iterator(_M_data() + this->size()); } const_iterator end() const noexcept { return const_iterator(_M_data() + this->size()); } reverse_iterator rbegin() noexcept { return reverse_iterator(this->end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(this->end()); } reverse_iterator rend() noexcept { return reverse_iterator(this->begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(this->begin()); } const_iterator cbegin() const noexcept { return const_iterator(this->_M_data()); } const_iterator cend() const noexcept { return const_iterator(this->_M_data() + this->size()); } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->end()); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->begin()); } public: size_type size() const noexcept { return _M_string_length; } size_type length() const noexcept { return _M_string_length; } size_type max_size() const noexcept { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; } # 925 "/usr/include/c++/10/bits/basic_string.h" 3 void resize(size_type __n, _CharT __c); # 938 "/usr/include/c++/10/bits/basic_string.h" 3 void resize(size_type __n) { this->resize(__n, _CharT()); } void shrink_to_fit() noexcept { if (capacity() > size()) { try { reserve(0); } catch(...) { } } } size_type capacity() const noexcept { return _M_is_local() ? size_type(_S_local_capacity) : _M_allocated_capacity; } # 987 "/usr/include/c++/10/bits/basic_string.h" 3 void reserve(size_type __res_arg = 0); void clear() noexcept { _M_set_length(0); } [[__nodiscard__]] bool empty() const noexcept { return this->size() == 0; } # 1016 "/usr/include/c++/10/bits/basic_string.h" 3 const_reference operator[] (size_type __pos) const noexcept { ; return _M_data()[__pos]; } # 1033 "/usr/include/c++/10/bits/basic_string.h" 3 reference operator[](size_type __pos) { ; ; return _M_data()[__pos]; } # 1054 "/usr/include/c++/10/bits/basic_string.h" 3 const_reference at(size_type __n) const { if (__n >= this->size()) __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); return _M_data()[__n]; } # 1075 "/usr/include/c++/10/bits/basic_string.h" 3 reference at(size_type __n) { if (__n >= size()) __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); return _M_data()[__n]; } reference front() noexcept { ; return operator[](0); } const_reference front() const noexcept { ; return operator[](0); } reference back() noexcept { ; return operator[](this->size() - 1); } const_reference back() const noexcept { ; return operator[](this->size() - 1); } # 1138 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& operator+=(const basic_string& __str) { return this->append(__str); } basic_string& operator+=(const _CharT* __s) { return this->append(__s); } basic_string& operator+=(_CharT __c) { this->push_back(__c); return *this; } basic_string& operator+=(initializer_list<_CharT> __l) { return this->append(__l.begin(), __l.size()); } # 1180 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> operator+=(const _Tp& __svt) { return this->append(__svt); } basic_string& append(const basic_string& __str) { return _M_append(__str._M_data(), __str.size()); } # 1208 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& append(const basic_string& __str, size_type __pos, size_type __n = npos) { return _M_append(__str._M_data() + __str._M_check(__pos, "basic_string::append"), __str._M_limit(__pos, __n)); } basic_string& append(const _CharT* __s, size_type __n) { ; _M_check_length(size_type(0), __n, "basic_string::append"); return _M_append(__s, __n); } basic_string& append(const _CharT* __s) { ; const size_type __n = traits_type::length(__s); _M_check_length(size_type(0), __n, "basic_string::append"); return _M_append(__s, __n); } # 1250 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& append(size_type __n, _CharT __c) { return _M_replace_aux(this->size(), size_type(0), __n, __c); } basic_string& append(initializer_list<_CharT> __l) { return this->append(__l.begin(), __l.size()); } # 1274 "/usr/include/c++/10/bits/basic_string.h" 3 template> basic_string& append(_InputIterator __first, _InputIterator __last) { return this->replace(end(), end(), __first, __last); } template _If_sv<_Tp, basic_string&> append(const _Tp& __svt) { __sv_type __sv = __svt; return this->append(__sv.data(), __sv.size()); } # 1304 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> append(const _Tp& __svt, size_type __pos, size_type __n = npos) { __sv_type __sv = __svt; return _M_append(__sv.data() + std::__sv_check(__sv.size(), __pos, "basic_string::append"), std::__sv_limit(__sv.size(), __pos, __n)); } void push_back(_CharT __c) { const size_type __size = this->size(); if (__size + 1 > this->capacity()) this->_M_mutate(__size, size_type(0), 0, size_type(1)); traits_type::assign(this->_M_data()[__size], __c); this->_M_set_length(__size + 1); } basic_string& assign(const basic_string& __str) { if (_Alloc_traits::_S_propagate_on_copy_assign()) { if (!_Alloc_traits::_S_always_equal() && !_M_is_local() && _M_get_allocator() != __str._M_get_allocator()) { if (__str.size() <= _S_local_capacity) { _M_destroy(_M_allocated_capacity); _M_data(_M_local_data()); _M_set_length(0); } else { const auto __len = __str.size(); auto __alloc = __str._M_get_allocator(); auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1); _M_destroy(_M_allocated_capacity); _M_data(__ptr); _M_capacity(__len); _M_set_length(__len); } } std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator()); } this->_M_assign(__str); return *this; } # 1379 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& assign(basic_string&& __str) noexcept(_Alloc_traits::_S_nothrow_move()) { return *this = std::move(__str); } # 1402 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n = npos) { return _M_replace(size_type(0), this->size(), __str._M_data() + __str._M_check(__pos, "basic_string::assign"), __str._M_limit(__pos, __n)); } # 1418 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& assign(const _CharT* __s, size_type __n) { ; return _M_replace(size_type(0), this->size(), __s, __n); } # 1434 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& assign(const _CharT* __s) { ; return _M_replace(size_type(0), this->size(), __s, traits_type::length(__s)); } # 1451 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& assign(size_type __n, _CharT __c) { return _M_replace_aux(size_type(0), this->size(), __n, __c); } # 1464 "/usr/include/c++/10/bits/basic_string.h" 3 template> basic_string& assign(_InputIterator __first, _InputIterator __last) { return this->replace(begin(), end(), __first, __last); } basic_string& assign(initializer_list<_CharT> __l) { return this->assign(__l.begin(), __l.size()); } # 1490 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> assign(const _Tp& __svt) { __sv_type __sv = __svt; return this->assign(__sv.data(), __sv.size()); } # 1505 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> assign(const _Tp& __svt, size_type __pos, size_type __n = npos) { __sv_type __sv = __svt; return _M_replace(size_type(0), this->size(), __sv.data() + std::__sv_check(__sv.size(), __pos, "basic_string::assign"), std::__sv_limit(__sv.size(), __pos, __n)); } # 1533 "/usr/include/c++/10/bits/basic_string.h" 3 iterator insert(const_iterator __p, size_type __n, _CharT __c) { ; const size_type __pos = __p - begin(); this->replace(__p, __p, __n, __c); return iterator(this->_M_data() + __pos); } # 1575 "/usr/include/c++/10/bits/basic_string.h" 3 template> iterator insert(const_iterator __p, _InputIterator __beg, _InputIterator __end) { ; const size_type __pos = __p - begin(); this->replace(__p, __p, __beg, __end); return iterator(this->_M_data() + __pos); } # 1611 "/usr/include/c++/10/bits/basic_string.h" 3 iterator insert(const_iterator __p, initializer_list<_CharT> __l) { return this->insert(__p, __l.begin(), __l.end()); } # 1638 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& insert(size_type __pos1, const basic_string& __str) { return this->replace(__pos1, size_type(0), __str._M_data(), __str.size()); } # 1661 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n = npos) { return this->replace(__pos1, size_type(0), __str._M_data() + __str._M_check(__pos2, "basic_string::insert"), __str._M_limit(__pos2, __n)); } # 1684 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& insert(size_type __pos, const _CharT* __s, size_type __n) { return this->replace(__pos, size_type(0), __s, __n); } # 1703 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& insert(size_type __pos, const _CharT* __s) { ; return this->replace(__pos, size_type(0), __s, traits_type::length(__s)); } # 1727 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& insert(size_type __pos, size_type __n, _CharT __c) { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), size_type(0), __n, __c); } # 1745 "/usr/include/c++/10/bits/basic_string.h" 3 iterator insert(__const_iterator __p, _CharT __c) { ; const size_type __pos = __p - begin(); _M_replace_aux(__pos, size_type(0), size_type(1), __c); return iterator(_M_data() + __pos); } # 1761 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> insert(size_type __pos, const _Tp& __svt) { __sv_type __sv = __svt; return this->insert(__pos, __sv.data(), __sv.size()); } # 1777 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> insert(size_type __pos1, const _Tp& __svt, size_type __pos2, size_type __n = npos) { __sv_type __sv = __svt; return this->replace(__pos1, size_type(0), __sv.data() + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"), std::__sv_limit(__sv.size(), __pos2, __n)); } # 1805 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& erase(size_type __pos = 0, size_type __n = npos) { _M_check(__pos, "basic_string::erase"); if (__n == npos) this->_M_set_length(__pos); else if (__n != 0) this->_M_erase(__pos, _M_limit(__pos, __n)); return *this; } # 1824 "/usr/include/c++/10/bits/basic_string.h" 3 iterator erase(__const_iterator __position) { ; const size_type __pos = __position - begin(); this->_M_erase(__pos, size_type(1)); return iterator(_M_data() + __pos); } # 1843 "/usr/include/c++/10/bits/basic_string.h" 3 iterator erase(__const_iterator __first, __const_iterator __last) { ; const size_type __pos = __first - begin(); if (__last == end()) this->_M_set_length(__pos); else this->_M_erase(__pos, __last - __first); return iterator(this->_M_data() + __pos); } void pop_back() noexcept { ; _M_erase(size() - 1, 1); } # 1887 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n, const basic_string& __str) { return this->replace(__pos, __n, __str._M_data(), __str.size()); } # 1909 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos) { return this->replace(__pos1, __n1, __str._M_data() + __str._M_check(__pos2, "basic_string::replace"), __str._M_limit(__pos2, __n2)); } # 1934 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) { ; return _M_replace(_M_check(__pos, "basic_string::replace"), _M_limit(__pos, __n1), __s, __n2); } # 1959 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n1, const _CharT* __s) { ; return this->replace(__pos, __n1, __s, traits_type::length(__s)); } # 1983 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), _M_limit(__pos, __n1), __n2, __c); } # 2001 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, const basic_string& __str) { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } # 2021 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s, size_type __n) { ; return this->replace(__i1 - begin(), __i2 - __i1, __s, __n); } # 2043 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s) { ; return this->replace(__i1, __i2, __s, traits_type::length(__s)); } # 2064 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, size_type __n, _CharT __c) { ; return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c); } # 2089 "/usr/include/c++/10/bits/basic_string.h" 3 template> basic_string& replace(const_iterator __i1, const_iterator __i2, _InputIterator __k1, _InputIterator __k2) { ; ; return this->_M_replace_dispatch(__i1, __i2, __k1, __k2, std::__false_type()); } # 2121 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(__const_iterator __i1, __const_iterator __i2, _CharT* __k1, _CharT* __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1, __k2 - __k1); } basic_string& replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __k1, const _CharT* __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1, __k2 - __k1); } basic_string& replace(__const_iterator __i1, __const_iterator __i2, iterator __k1, iterator __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1.base(), __k2 - __k1); } basic_string& replace(__const_iterator __i1, __const_iterator __i2, const_iterator __k1, const_iterator __k2) { ; ; return this->replace(__i1 - begin(), __i2 - __i1, __k1.base(), __k2 - __k1); } # 2180 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<_CharT> __l) { return this->replace(__i1, __i2, __l.begin(), __l.size()); } # 2193 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> replace(size_type __pos, size_type __n, const _Tp& __svt) { __sv_type __sv = __svt; return this->replace(__pos, __n, __sv.data(), __sv.size()); } # 2210 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, basic_string&> replace(size_type __pos1, size_type __n1, const _Tp& __svt, size_type __pos2, size_type __n2 = npos) { __sv_type __sv = __svt; return this->replace(__pos1, __n1, __sv.data() + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"), std::__sv_limit(__sv.size(), __pos2, __n2)); } # 2231 "/usr/include/c++/10/bits/basic_string.h" 3 template _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 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 basic_string& _M_replace_dispatch(const_iterator __i1, const_iterator __i2, _InputIterator __k1, _InputIterator __k2, __false_type); basic_string& _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, _CharT __c); basic_string& _M_replace(size_type __pos, size_type __len1, const _CharT* __s, const size_type __len2); basic_string& _M_append(const _CharT* __s, size_type __n); public: # 2278 "/usr/include/c++/10/bits/basic_string.h" 3 size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const; # 2288 "/usr/include/c++/10/bits/basic_string.h" 3 void swap(basic_string& __s) noexcept; # 2298 "/usr/include/c++/10/bits/basic_string.h" 3 const _CharT* c_str() const noexcept { return _M_data(); } # 2310 "/usr/include/c++/10/bits/basic_string.h" 3 const _CharT* data() const noexcept { return _M_data(); } # 2321 "/usr/include/c++/10/bits/basic_string.h" 3 _CharT* data() noexcept { return _M_data(); } allocator_type get_allocator() const noexcept { return _M_get_allocator(); } # 2345 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 2359 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find(const basic_string& __str, size_type __pos = 0) const noexcept { return this->find(__str.data(), __pos, __str.size()); } # 2371 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, size_type> find(const _Tp& __svt, size_type __pos = 0) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find(__sv.data(), __pos, __sv.size()); } # 2391 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find(const _CharT* __s, size_type __pos = 0) const noexcept { ; return this->find(__s, __pos, traits_type::length(__s)); } # 2408 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find(_CharT __c, size_type __pos = 0) const noexcept; # 2421 "/usr/include/c++/10/bits/basic_string.h" 3 size_type rfind(const basic_string& __str, size_type __pos = npos) const noexcept { return this->rfind(__str.data(), __pos, __str.size()); } # 2433 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, size_type> rfind(const _Tp& __svt, size_type __pos = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->rfind(__sv.data(), __pos, __sv.size()); } # 2455 "/usr/include/c++/10/bits/basic_string.h" 3 size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 2469 "/usr/include/c++/10/bits/basic_string.h" 3 size_type rfind(const _CharT* __s, size_type __pos = npos) const { ; return this->rfind(__s, __pos, traits_type::length(__s)); } # 2486 "/usr/include/c++/10/bits/basic_string.h" 3 size_type rfind(_CharT __c, size_type __pos = npos) const noexcept; # 2500 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_of(const basic_string& __str, size_type __pos = 0) const noexcept { return this->find_first_of(__str.data(), __pos, __str.size()); } # 2513 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, size_type> find_first_of(const _Tp& __svt, size_type __pos = 0) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_first_of(__sv.data(), __pos, __sv.size()); } # 2535 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 2549 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_of(const _CharT* __s, size_type __pos = 0) const noexcept { ; return this->find_first_of(__s, __pos, traits_type::length(__s)); } # 2569 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_of(_CharT __c, size_type __pos = 0) const noexcept { return this->find(__c, __pos); } # 2584 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_of(const basic_string& __str, size_type __pos = npos) const noexcept { return this->find_last_of(__str.data(), __pos, __str.size()); } # 2597 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, size_type> find_last_of(const _Tp& __svt, size_type __pos = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_last_of(__sv.data(), __pos, __sv.size()); } # 2619 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 2633 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_of(const _CharT* __s, size_type __pos = npos) const noexcept { ; return this->find_last_of(__s, __pos, traits_type::length(__s)); } # 2653 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_of(_CharT __c, size_type __pos = npos) const noexcept { return this->rfind(__c, __pos); } # 2667 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const noexcept { return this->find_first_not_of(__str.data(), __pos, __str.size()); } # 2680 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, size_type> find_first_not_of(const _Tp& __svt, size_type __pos = 0) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_first_not_of(__sv.data(), __pos, __sv.size()); } # 2702 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 2716 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const noexcept { ; return this->find_first_not_of(__s, __pos, traits_type::length(__s)); } # 2734 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; # 2749 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const noexcept { return this->find_last_not_of(__str.data(), __pos, __str.size()); } # 2762 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, size_type> find_last_not_of(const _Tp& __svt, size_type __pos = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return this->find_last_not_of(__sv.data(), __pos, __sv.size()); } # 2784 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const noexcept; # 2798 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const noexcept { ; return this->find_last_not_of(__s, __pos, traits_type::length(__s)); } # 2816 "/usr/include/c++/10/bits/basic_string.h" 3 size_type find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; # 2832 "/usr/include/c++/10/bits/basic_string.h" 3 basic_string substr(size_type __pos = 0, size_type __n = npos) const { return basic_string(*this, _M_check(__pos, "basic_string::substr"), __n); } # 2851 "/usr/include/c++/10/bits/basic_string.h" 3 int compare(const basic_string& __str) const { const size_type __size = this->size(); const size_type __osize = __str.size(); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __str.data(), __len); if (!__r) __r = _S_compare(__size, __osize); return __r; } template _If_sv<_Tp, int> compare(const _Tp& __svt) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; const size_type __size = this->size(); const size_type __osize = __sv.size(); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __sv.data(), __len); if (!__r) __r = _S_compare(__size, __osize); return __r; } # 2894 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, int> compare(size_type __pos, size_type __n, const _Tp& __svt) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return __sv_type(*this).substr(__pos, __n).compare(__sv); } # 2913 "/usr/include/c++/10/bits/basic_string.h" 3 template _If_sv<_Tp, int> compare(size_type __pos1, size_type __n1, const _Tp& __svt, size_type __pos2, size_type __n2 = npos) const noexcept(is_same<_Tp, __sv_type>::value) { __sv_type __sv = __svt; return __sv_type(*this) .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); } # 2944 "/usr/include/c++/10/bits/basic_string.h" 3 int compare(size_type __pos, size_type __n, const basic_string& __str) const; # 2970 "/usr/include/c++/10/bits/basic_string.h" 3 int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos) const; # 2988 "/usr/include/c++/10/bits/basic_string.h" 3 int compare(const _CharT* __s) const noexcept; # 3012 "/usr/include/c++/10/bits/basic_string.h" 3 int compare(size_type __pos, size_type __n1, const _CharT* __s) const; # 3039 "/usr/include/c++/10/bits/basic_string.h" 3 int compare(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) const; bool starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept { return __sv_type(this->data(), this->size()).starts_with(__x); } bool starts_with(_CharT __x) const noexcept { return __sv_type(this->data(), this->size()).starts_with(__x); } bool starts_with(const _CharT* __x) const noexcept { return __sv_type(this->data(), this->size()).starts_with(__x); } bool ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept { return __sv_type(this->data(), this->size()).ends_with(__x); } bool ends_with(_CharT __x) const noexcept { return __sv_type(this->data(), this->size()).ends_with(__x); } bool ends_with(const _CharT* __x) const noexcept { return __sv_type(this->data(), this->size()).ends_with(__x); } template friend class basic_stringbuf; }; } # 5995 "/usr/include/c++/10/bits/basic_string.h" 3 namespace __cxx11 { template::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 = _RequireAllocator<_Allocator>> basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator()) -> basic_string<_CharT, _Traits, _Allocator>; template, 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>; } # 6030 "/usr/include/c++/10/bits/basic_string.h" 3 template basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { basic_string<_CharT, _Traits, _Alloc> __str(__lhs); __str.append(__rhs); return __str; } template basic_string<_CharT,_Traits,_Alloc> operator+(const _CharT* __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); template basic_string<_CharT,_Traits,_Alloc> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); template inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { basic_string<_CharT, _Traits, _Alloc> __str(__lhs); __str.append(__rhs); return __str; } template inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) { typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __string_type::size_type __size_type; __string_type __str(__lhs); __str.append(__size_type(1), __rhs); return __str; } template 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 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 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 inline basic_string<_CharT, _Traits, _Alloc> operator+(const _CharT* __lhs, basic_string<_CharT, _Traits, _Alloc>&& __rhs) { return std::move(__rhs.insert(0, __lhs)); } template inline basic_string<_CharT, _Traits, _Alloc> operator+(_CharT __lhs, basic_string<_CharT, _Traits, _Alloc>&& __rhs) { return std::move(__rhs.insert(0, 1, __lhs)); } template inline basic_string<_CharT, _Traits, _Alloc> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, const _CharT* __rhs) { return std::move(__lhs.append(__rhs)); } template inline basic_string<_CharT, _Traits, _Alloc> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, _CharT __rhs) { return std::move(__lhs.append(1, __rhs)); } # 6161 "/usr/include/c++/10/bits/basic_string.h" 3 template inline bool operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept { return __lhs.compare(__rhs) == 0; } template inline typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type operator==(const basic_string<_CharT>& __lhs, const basic_string<_CharT>& __rhs) noexcept { return (__lhs.size() == __rhs.size() && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(), __lhs.size())); } template inline bool operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) == 0; } # 6197 "/usr/include/c++/10/bits/basic_string.h" 3 template inline 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)); } # 6211 "/usr/include/c++/10/bits/basic_string.h" 3 template inline 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)); } # 6428 "/usr/include/c++/10/bits/basic_string.h" 3 template inline void swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } # 6448 "/usr/include/c++/10/bits/basic_string.h" 3 template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str); template<> basic_istream& operator>>(basic_istream& __is, basic_string& __str); # 6466 "/usr/include/c++/10/bits/basic_string.h" 3 template 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()); } # 6489 "/usr/include/c++/10/bits/basic_string.h" 3 template basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); # 6506 "/usr/include/c++/10/bits/basic_string.h" 3 template 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 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 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& getline(basic_istream& __in, basic_string& __str, char __delim); template<> basic_istream& getline(basic_istream& __in, basic_string& __str, wchar_t __delim); } # 1 "/usr/include/c++/10/ext/string_conversions.h" 1 3 # 32 "/usr/include/c++/10/ext/string_conversions.h" 3 # 33 "/usr/include/c++/10/ext/string_conversions.h" 3 # 41 "/usr/include/c++/10/ext/string_conversions.h" 3 # 1 "/usr/include/c++/10/cstdlib" 1 3 # 39 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/cstdlib" 3 # 42 "/usr/include/c++/10/ext/string_conversions.h" 2 3 # 1 "/usr/include/c++/10/cwchar" 1 3 # 39 "/usr/include/c++/10/cwchar" 3 # 40 "/usr/include/c++/10/cwchar" 3 # 43 "/usr/include/c++/10/ext/string_conversions.h" 2 3 # 1 "/usr/include/c++/10/cstdio" 1 3 # 39 "/usr/include/c++/10/cstdio" 3 # 40 "/usr/include/c++/10/cstdio" 3 # 1 "/usr/include/stdio.h" 1 3 4 # 27 "/usr/include/stdio.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 28 "/usr/include/stdio.h" 2 3 4 extern "C" { # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 34 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 1 3 4 # 37 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4 # 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 3 4 typedef struct _G_fpos_t { __off_t __pos; __mbstate_t __state; } __fpos_t; # 40 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4 # 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4 typedef struct _G_fpos64_t { __off64_t __pos; __mbstate_t __state; } __fpos64_t; # 41 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4 # 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4 struct _IO_FILE; struct _IO_marker; struct _IO_codecvt; struct _IO_wide_data; typedef void _IO_lock_t; struct _IO_FILE { int _flags; char *_IO_read_ptr; char *_IO_read_end; char *_IO_read_base; char *_IO_write_base; char *_IO_write_ptr; char *_IO_write_end; char *_IO_buf_base; char *_IO_buf_end; char *_IO_save_base; char *_IO_backup_base; char *_IO_save_end; struct _IO_marker *_markers; struct _IO_FILE *_chain; int _fileno; int _flags2; __off_t _old_offset; unsigned short _cur_column; signed char _vtable_offset; char _shortbuf[1]; _IO_lock_t *_lock; __off64_t _offset; struct _IO_codecvt *_codecvt; struct _IO_wide_data *_wide_data; struct _IO_FILE *_freeres_list; void *_freeres_buf; size_t __pad5; int _mode; char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; }; # 44 "/usr/include/stdio.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h" 3 4 typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, size_t __nbytes); typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, size_t __nbytes); typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); typedef int cookie_close_function_t (void *__cookie); typedef struct _IO_cookie_io_functions_t { cookie_read_function_t *read; cookie_write_function_t *write; cookie_seek_function_t *seek; cookie_close_function_t *close; } cookie_io_functions_t; # 47 "/usr/include/stdio.h" 2 3 4 typedef __gnuc_va_list va_list; # 84 "/usr/include/stdio.h" 3 4 typedef __fpos_t fpos_t; typedef __fpos64_t fpos64_t; # 133 "/usr/include/stdio.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4 # 134 "/usr/include/stdio.h" 2 3 4 extern FILE *stdin; extern FILE *stdout; extern FILE *stderr; extern int remove (const char *__filename) throw (); extern int rename (const char *__old, const char *__new) throw (); extern int renameat (int __oldfd, const char *__old, int __newfd, const char *__new) throw (); # 164 "/usr/include/stdio.h" 3 4 extern int renameat2 (int __oldfd, const char *__old, int __newfd, const char *__new, unsigned int __flags) throw (); extern FILE *tmpfile (void) ; # 183 "/usr/include/stdio.h" 3 4 extern FILE *tmpfile64 (void) ; extern char *tmpnam (char *__s) throw () ; extern char *tmpnam_r (char *__s) throw () ; # 204 "/usr/include/stdio.h" 3 4 extern char *tempnam (const char *__dir, const char *__pfx) throw () __attribute__ ((__malloc__)) ; extern int fclose (FILE *__stream); extern int fflush (FILE *__stream); # 227 "/usr/include/stdio.h" 3 4 extern int fflush_unlocked (FILE *__stream); # 237 "/usr/include/stdio.h" 3 4 extern int fcloseall (void); # 246 "/usr/include/stdio.h" 3 4 extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) ; extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) ; # 270 "/usr/include/stdio.h" 3 4 extern FILE *fopen64 (const char *__restrict __filename, const char *__restrict __modes) ; extern FILE *freopen64 (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) ; extern FILE *fdopen (int __fd, const char *__modes) throw () ; extern FILE *fopencookie (void *__restrict __magic_cookie, const char *__restrict __modes, cookie_io_functions_t __io_funcs) throw () ; extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) throw () ; extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ; extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw (); extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, int __modes, size_t __n) throw (); extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, size_t __size) throw (); extern void setlinebuf (FILE *__stream) throw (); extern int fprintf (FILE *__restrict __stream, const char *__restrict __format, ...); extern int printf (const char *__restrict __format, ...); extern int sprintf (char *__restrict __s, const char *__restrict __format, ...) throw (); extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg); extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); extern int vsprintf (char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw (); extern int snprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, ...) throw () __attribute__ ((__format__ (__printf__, 3, 4))); extern int vsnprintf (char *__restrict __s, size_t __maxlen, const char *__restrict __format, __gnuc_va_list __arg) throw () __attribute__ ((__format__ (__printf__, 3, 0))); extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, __gnuc_va_list __arg) throw () __attribute__ ((__format__ (__printf__, 2, 0))) ; extern int __asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; extern int asprintf (char **__restrict __ptr, const char *__restrict __fmt, ...) throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; extern int vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __arg) __attribute__ ((__format__ (__printf__, 2, 0))); extern int dprintf (int __fd, const char *__restrict __fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) ; extern int scanf (const char *__restrict __format, ...) ; extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) throw (); extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf") ; extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf") ; extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) throw () __asm__ ("" "__isoc99_sscanf") ; # 432 "/usr/include/stdio.h" 3 4 extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 2, 0))) ; extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __attribute__ ((__format__ (__scanf__, 1, 0))) ; extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw () __attribute__ ((__format__ (__scanf__, 2, 0))); extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf") __attribute__ ((__format__ (__scanf__, 2, 0))) ; extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf") __attribute__ ((__format__ (__scanf__, 1, 0))) ; extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__format__ (__scanf__, 2, 0))); # 485 "/usr/include/stdio.h" 3 4 extern int fgetc (FILE *__stream); extern int getc (FILE *__stream); extern int getchar (void); extern int getc_unlocked (FILE *__stream); extern int getchar_unlocked (void); # 510 "/usr/include/stdio.h" 3 4 extern int fgetc_unlocked (FILE *__stream); # 521 "/usr/include/stdio.h" 3 4 extern int fputc (int __c, FILE *__stream); extern int putc (int __c, FILE *__stream); extern int putchar (int __c); # 537 "/usr/include/stdio.h" 3 4 extern int fputc_unlocked (int __c, FILE *__stream); extern int putc_unlocked (int __c, FILE *__stream); extern int putchar_unlocked (int __c); extern int getw (FILE *__stream); extern int putw (int __w, FILE *__stream); extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) ; # 587 "/usr/include/stdio.h" 3 4 extern char *fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) ; # 603 "/usr/include/stdio.h" 3 4 extern __ssize_t __getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) ; extern __ssize_t getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) ; extern __ssize_t getline (char **__restrict __lineptr, size_t *__restrict __n, FILE *__restrict __stream) ; extern int fputs (const char *__restrict __s, FILE *__restrict __stream); extern int puts (const char *__s); extern int ungetc (int __c, FILE *__stream); extern size_t fread (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) ; extern size_t fwrite (const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __s); # 662 "/usr/include/stdio.h" 3 4 extern int fputs_unlocked (const char *__restrict __s, FILE *__restrict __stream); # 673 "/usr/include/stdio.h" 3 4 extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) ; extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream); extern int fseek (FILE *__stream, long int __off, int __whence); extern long int ftell (FILE *__stream) ; extern void rewind (FILE *__stream); # 707 "/usr/include/stdio.h" 3 4 extern int fseeko (FILE *__stream, __off_t __off, int __whence); extern __off_t ftello (FILE *__stream) ; # 731 "/usr/include/stdio.h" 3 4 extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); extern int fsetpos (FILE *__stream, const fpos_t *__pos); # 750 "/usr/include/stdio.h" 3 4 extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); extern __off64_t ftello64 (FILE *__stream) ; extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); extern void clearerr (FILE *__stream) throw (); extern int feof (FILE *__stream) throw () ; extern int ferror (FILE *__stream) throw () ; extern void clearerr_unlocked (FILE *__stream) throw (); extern int feof_unlocked (FILE *__stream) throw () ; extern int ferror_unlocked (FILE *__stream) throw () ; extern void perror (const char *__s); # 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4 # 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4 extern int sys_nerr; extern const char *const sys_errlist[]; extern int _sys_nerr; extern const char *const _sys_errlist[]; # 782 "/usr/include/stdio.h" 2 3 4 extern int fileno (FILE *__stream) throw () ; extern int fileno_unlocked (FILE *__stream) throw () ; # 800 "/usr/include/stdio.h" 3 4 extern FILE *popen (const char *__command, const char *__modes) ; extern int pclose (FILE *__stream); extern char *ctermid (char *__s) throw (); extern char *cuserid (char *__s); struct obstack; extern int obstack_printf (struct obstack *__restrict __obstack, const char *__restrict __format, ...) throw () __attribute__ ((__format__ (__printf__, 2, 3))); extern int obstack_vprintf (struct obstack *__restrict __obstack, const char *__restrict __format, __gnuc_va_list __args) throw () __attribute__ ((__format__ (__printf__, 2, 0))); extern void flockfile (FILE *__stream) throw (); extern int ftrylockfile (FILE *__stream) throw () ; extern void funlockfile (FILE *__stream) throw (); # 858 "/usr/include/stdio.h" 3 4 extern int __uflow (FILE *); extern int __overflow (FILE *, int); # 873 "/usr/include/stdio.h" 3 4 } # 43 "/usr/include/c++/10/cstdio" 2 3 # 96 "/usr/include/c++/10/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 "/usr/include/c++/10/cstdio" 3 namespace __gnu_cxx { # 175 "/usr/include/c++/10/cstdio" 3 using ::snprintf; using ::vfscanf; using ::vscanf; using ::vsnprintf; using ::vsscanf; } namespace std { using ::__gnu_cxx::snprintf; using ::__gnu_cxx::vfscanf; using ::__gnu_cxx::vscanf; using ::__gnu_cxx::vsnprintf; using ::__gnu_cxx::vsscanf; } # 44 "/usr/include/c++/10/ext/string_conversions.h" 2 3 # 1 "/usr/include/c++/10/cerrno" 1 3 # 39 "/usr/include/c++/10/cerrno" 3 # 40 "/usr/include/c++/10/cerrno" 3 # 1 "/usr/include/errno.h" 1 3 4 # 28 "/usr/include/errno.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/errno.h" 1 3 4 # 26 "/usr/include/x86_64-linux-gnu/bits/errno.h" 3 4 # 1 "/usr/include/linux/errno.h" 1 3 4 # 1 "/usr/include/x86_64-linux-gnu/asm/errno.h" 1 3 4 # 1 "/usr/include/asm-generic/errno.h" 1 3 4 # 1 "/usr/include/asm-generic/errno-base.h" 1 3 4 # 6 "/usr/include/asm-generic/errno.h" 2 3 4 # 2 "/usr/include/x86_64-linux-gnu/asm/errno.h" 2 3 4 # 2 "/usr/include/linux/errno.h" 2 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/errno.h" 2 3 4 # 29 "/usr/include/errno.h" 2 3 4 extern "C" { extern int *__errno_location (void) throw () __attribute__ ((__const__)); extern char *program_invocation_name; extern char *program_invocation_short_name; # 1 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 1 3 4 # 22 "/usr/include/x86_64-linux-gnu/bits/types/error_t.h" 3 4 typedef int error_t; # 49 "/usr/include/errno.h" 2 3 4 } # 43 "/usr/include/c++/10/cerrno" 2 3 # 45 "/usr/include/c++/10/ext/string_conversions.h" 2 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { template _Ret __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...), const char* __name, const _CharT* __str, std::size_t* __idx, _Base... __base) { _Ret __ret; _CharT* __endptr; struct _Save_errno { _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; } ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; } int _M_errno; } const __save_errno; struct _Range_chk { static bool _S_chk(_TRet, std::false_type) { return false; } static bool _S_chk(_TRet __val, std::true_type) { return __val < _TRet(__numeric_traits::__min) || __val > _TRet(__numeric_traits::__max); } }; const _TRet __tmp = __convf(__str, &__endptr, __base...); if (__endptr == __str) std::__throw_invalid_argument(__name); else if ((*__errno_location ()) == 34 || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{})) std::__throw_out_of_range(__name); else __ret = __tmp; if (__idx) *__idx = __endptr - __str; return __ret; } template _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); } } # 6546 "/usr/include/c++/10/bits/basic_string.h" 2 3 # 1 "/usr/include/c++/10/bits/charconv.h" 1 3 # 33 "/usr/include/c++/10/bits/charconv.h" 3 # 34 "/usr/include/c++/10/bits/charconv.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template constexpr unsigned __to_chars_len(_Tp __value, int __base = 10) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); unsigned __n = 1; const unsigned __b2 = __base * __base; const unsigned __b3 = __b2 * __base; const unsigned long __b4 = __b3 * __base; for (;;) { if (__value < (unsigned)__base) return __n; if (__value < __b2) return __n + 1; if (__value < __b3) return __n + 2; if (__value < __b4) return __n + 3; __value /= __b4; __n += 4; } } template void __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); static constexpr char __digits[201] = "0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899"; unsigned __pos = __len - 1; while (__val >= 100) { auto const __num = (__val % 100) * 2; __val /= 100; __first[__pos] = __digits[__num + 1]; __first[__pos - 1] = __digits[__num]; __pos -= 2; } if (__val >= 10) { auto const __num = __val * 2; __first[1] = __digits[__num + 1]; __first[0] = __digits[__num]; } else __first[0] = '0' + __val; } } } # 6547 "/usr/include/c++/10/bits/basic_string.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { inline int stoi(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtol, "stoi", __str.c_str(), __idx, __base); } inline long stol(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), __idx, __base); } inline unsigned long stoul(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), __idx, __base); } inline long long stoll(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), __idx, __base); } inline unsigned long long stoull(const string& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), __idx, __base); } inline float stof(const string& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } inline double stod(const string& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } inline long double stold(const string& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); } inline string to_string(int __val) { const bool __neg = __val < 0; const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val; const auto __len = __detail::__to_chars_len(__uval); string __str(__neg + __len, '-'); __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); return __str; } inline string to_string(unsigned __val) { string __str(__detail::__to_chars_len(__val), '\0'); __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); return __str; } inline string to_string(long __val) { const bool __neg = __val < 0; const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val; const auto __len = __detail::__to_chars_len(__uval); string __str(__neg + __len, '-'); __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); return __str; } inline string to_string(unsigned long __val) { string __str(__detail::__to_chars_len(__val), '\0'); __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); return __str; } inline string to_string(long long __val) { const bool __neg = __val < 0; const unsigned long long __uval = __neg ? (unsigned long long)~__val + 1ull : __val; const auto __len = __detail::__to_chars_len(__uval); string __str(__neg + __len, '-'); __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); return __str; } inline string to_string(unsigned long long __val) { string __str(__detail::__to_chars_len(__val), '\0'); __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); return __str; } inline string to_string(float __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, "%f", __val); } inline string to_string(double __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, "%f", __val); } inline string to_string(long double __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, "%Lf", __val); } inline int stoi(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstol, "stoi", __str.c_str(), __idx, __base); } inline long stol(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), __idx, __base); } inline unsigned long stoul(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), __idx, __base); } inline long long stoll(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), __idx, __base); } inline unsigned long long stoull(const wstring& __str, size_t* __idx = 0, int __base = 10) { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), __idx, __base); } inline float stof(const wstring& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } inline double stod(const wstring& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } inline long double stold(const wstring& __str, size_t* __idx = 0) { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); } inline wstring to_wstring(int __val) { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(int), L"%d", __val); } inline wstring to_wstring(unsigned __val) { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(unsigned), L"%u", __val); } inline wstring to_wstring(long __val) { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(long), L"%ld", __val); } inline wstring to_wstring(unsigned long __val) { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(unsigned long), L"%lu", __val); } inline wstring to_wstring(long long __val) { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(long long), L"%lld", __val); } inline wstring to_wstring(unsigned long long __val) { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(unsigned long long), L"%llu", __val); } inline wstring to_wstring(float __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vswprintf, __n, L"%f", __val); } inline wstring to_wstring(double __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vswprintf, __n, L"%f", __val); } inline wstring to_wstring(long double __val) { const int __n = __gnu_cxx::__numeric_traits::__max_exponent10 + 20; return __gnu_cxx::__to_xstring(&std::vswprintf, __n, L"%Lf", __val); } } } namespace std __attribute__ ((__visibility__ ("default"))) { template<> struct hash : public __hash_base { size_t operator()(const string& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length()); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { size_t operator()(const wstring& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(wchar_t)); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { size_t operator()(const u8string& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char8_t)); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { size_t operator()(const u16string& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char16_t)); } }; template<> struct __is_fast_hash> : std::false_type { }; template<> struct hash : public __hash_base { size_t operator()(const u32string& __s) const noexcept { return std::_Hash_impl::hash(__s.data(), __s.length() * sizeof(char32_t)); } }; template<> struct __is_fast_hash> : std::false_type { }; inline namespace literals { inline namespace string_literals { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wliteral-suffix" __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const char* __str, size_t __len) { return basic_string{__str, __len}; } __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const wchar_t* __str, size_t __len) { return basic_string{__str, __len}; } __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const char8_t* __str, size_t __len) { return basic_string{__str, __len}; } __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const char16_t* __str, size_t __len) { return basic_string{__str, __len}; } __attribute ((__abi_tag__ ("cxx11"))) inline basic_string operator""s(const char32_t* __str, size_t __len) { return basic_string{__str, __len}; } #pragma GCC diagnostic pop } } namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : __and_< is_nothrow_move_constructible>, is_nothrow_move_assignable> >::type { }; } } # 56 "/usr/include/c++/10/string" 2 3 # 1 "/usr/include/c++/10/bits/basic_string.tcc" 1 3 # 42 "/usr/include/c++/10/bits/basic_string.tcc" 3 # 43 "/usr/include/c++/10/bits/basic_string.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template const typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>::npos; template void basic_string<_CharT, _Traits, _Alloc>:: swap(basic_string& __s) noexcept { if (this == &__s) return; _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator()); if (_M_is_local()) if (__s._M_is_local()) { if (length() && __s.length()) { _CharT __tmp_data[_S_local_capacity + 1]; traits_type::copy(__tmp_data, __s._M_local_buf, _S_local_capacity + 1); traits_type::copy(__s._M_local_buf, _M_local_buf, _S_local_capacity + 1); traits_type::copy(_M_local_buf, __tmp_data, _S_local_capacity + 1); } else if (__s.length()) { traits_type::copy(_M_local_buf, __s._M_local_buf, _S_local_capacity + 1); _M_length(__s.length()); __s._M_set_length(0); return; } else if (length()) { traits_type::copy(__s._M_local_buf, _M_local_buf, _S_local_capacity + 1); __s._M_length(length()); _M_set_length(0); return; } } else { const size_type __tmp_capacity = __s._M_allocated_capacity; traits_type::copy(__s._M_local_buf, _M_local_buf, _S_local_capacity + 1); _M_data(__s._M_data()); __s._M_data(__s._M_local_buf); _M_capacity(__tmp_capacity); } else { const size_type __tmp_capacity = _M_allocated_capacity; if (__s._M_is_local()) { traits_type::copy(_M_local_buf, __s._M_local_buf, _S_local_capacity + 1); __s._M_data(_M_data()); _M_data(_M_local_buf); } else { pointer __tmp_ptr = _M_data(); _M_data(__s._M_data()); __s._M_data(__tmp_ptr); _M_capacity(__s._M_allocated_capacity); } __s._M_capacity(__tmp_capacity); } const size_type __tmp_length = length(); _M_length(__s.length()); __s._M_length(__tmp_length); } template typename basic_string<_CharT, _Traits, _Alloc>::pointer basic_string<_CharT, _Traits, _Alloc>:: _M_create(size_type& __capacity, size_type __old_capacity) { if (__capacity > max_size()) std::__throw_length_error(("basic_string::_M_create")); if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) { __capacity = 2 * __old_capacity; if (__capacity > max_size()) __capacity = max_size(); } return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1); } template template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag) { size_type __len = 0; size_type __capacity = size_type(_S_local_capacity); while (__beg != __end && __len < __capacity) { _M_data()[__len++] = *__beg; ++__beg; } try { while (__beg != __end) { if (__len == __capacity) { __capacity = __len + 1; pointer __another = _M_create(__capacity, __len); this->_S_copy(__another, _M_data(), __len); _M_dispose(); _M_data(__another); _M_capacity(__capacity); } _M_data()[__len++] = *__beg; ++__beg; } } catch(...) { _M_dispose(); throw; } _M_set_length(__len); } template template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::forward_iterator_tag) { if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end) std::__throw_logic_error(("basic_string::" "_M_construct null not valid") ); size_type __dnew = static_cast(std::distance(__beg, __end)); if (__dnew > size_type(_S_local_capacity)) { _M_data(_M_create(__dnew, size_type(0))); _M_capacity(__dnew); } try { this->_S_copy_chars(_M_data(), __beg, __end); } catch(...) { _M_dispose(); throw; } _M_set_length(__dnew); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(size_type __n, _CharT __c) { if (__n > size_type(_S_local_capacity)) { _M_data(_M_create(__n, size_type(0))); _M_capacity(__n); } if (__n) this->_S_assign(_M_data(), __n, __c); _M_set_length(__n); } template void basic_string<_CharT, _Traits, _Alloc>:: _M_assign(const basic_string& __str) { if (this != &__str) { const size_type __rsize = __str.length(); const size_type __capacity = capacity(); if (__rsize > __capacity) { size_type __new_capacity = __rsize; pointer __tmp = _M_create(__new_capacity, __capacity); _M_dispose(); _M_data(__tmp); _M_capacity(__new_capacity); } if (__rsize) this->_S_copy(_M_data(), __str._M_data(), __rsize); _M_set_length(__rsize); } } template void basic_string<_CharT, _Traits, _Alloc>:: reserve(size_type __res) { if (__res < length()) __res = length(); const size_type __capacity = capacity(); if (__res != __capacity) { if (__res > __capacity || __res > size_type(_S_local_capacity)) { pointer __tmp = _M_create(__res, __capacity); this->_S_copy(__tmp, _M_data(), length() + 1); _M_dispose(); _M_data(__tmp); _M_capacity(__res); } else if (!_M_is_local()) { this->_S_copy(_M_local_data(), _M_data(), length() + 1); _M_destroy(__capacity); _M_data(_M_local_data()); } } } template 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 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 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 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 template 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 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 basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace(size_type __pos, size_type __len1, const _CharT* __s, const size_type __len2) { _M_check_length(__len1, __len2, "basic_string::_M_replace"); const size_type __old_size = this->size(); const size_type __new_size = __old_size + __len2 - __len1; if (__new_size <= this->capacity()) { pointer __p = this->_M_data() + __pos; const size_type __how_much = __old_size - __pos - __len1; if (_M_disjunct(__s)) { if (__how_much && __len1 != __len2) this->_S_move(__p + __len2, __p + __len1, __how_much); if (__len2) this->_S_copy(__p, __s, __len2); } else { if (__len2 && __len2 <= __len1) this->_S_move(__p, __s, __len2); if (__how_much && __len1 != __len2) this->_S_move(__p + __len2, __p + __len1, __how_much); if (__len2 > __len1) { if (__s + __len2 <= __p + __len1) this->_S_move(__p, __s, __len2); else if (__s >= __p + __len1) this->_S_copy(__p, __s + __len2 - __len1, __len2); else { const size_type __nleft = (__p + __len1) - __s; this->_S_move(__p, __s, __nleft); this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft); } } } } else this->_M_mutate(__pos, __len1, __s, __len2); this->_M_set_length(__new_size); return *this; } template typename 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; } # 1150 "/usr/include/c++/10/bits/basic_string.tcc" 3 template basic_string<_CharT, _Traits, _Alloc> operator+(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { ; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __string_type::size_type __size_type; typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_CharT>::other _Char_alloc_type; typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; const __size_type __len = _Traits::length(__lhs); __string_type __str(_Alloc_traits::_S_select_on_copy( __rhs.get_allocator())); __str.reserve(__len + __rhs.size()); __str.append(__lhs, __len); __str.append(__rhs); return __str; } template basic_string<_CharT, _Traits, _Alloc> operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __string_type::size_type __size_type; typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_CharT>::other _Char_alloc_type; typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; __string_type __str(_Alloc_traits::_S_select_on_copy( __rhs.get_allocator())); const __size_type __len = __rhs.size(); __str.reserve(__len + 1); __str.append(__size_type(1), __lhs); __str.append(__rhs); return __str; } template typename 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 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 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 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 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 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 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 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 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 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 int basic_string<_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n, const basic_string& __str) const { _M_check(__pos, "basic_string::compare"); __n = _M_limit(__pos, __n); const size_type __osize = __str.size(); const size_type __len = std::min(__n, __osize); int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); if (!__r) __r = _S_compare(__n, __osize); return __r; } template int basic_string<_CharT, _Traits, _Alloc>:: compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) const { _M_check(__pos1, "basic_string::compare"); __str._M_check(__pos2, "basic_string::compare"); __n1 = _M_limit(__pos1, __n1); __n2 = __str._M_limit(__pos2, __n2); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos1, __str.data() + __pos2, __len); if (!__r) __r = _S_compare(__n1, __n2); return __r; } template int basic_string<_CharT, _Traits, _Alloc>:: compare(const _CharT* __s) const noexcept { ; const size_type __size = this->size(); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __s, __len); if (!__r) __r = _S_compare(__size, __osize); return __r; } template int basic_string <_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n1, const _CharT* __s) const { ; _M_check(__pos, "basic_string::compare"); __n1 = _M_limit(__pos, __n1); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__n1, __osize); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = _S_compare(__n1, __osize); return __r; } template int basic_string <_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) const { ; _M_check(__pos, "basic_string::compare"); __n1 = _M_limit(__pos, __n1); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = _S_compare(__n1, __n2); return __r; } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, basic_string<_CharT, _Traits, _Alloc>& __str) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __istream_type::ios_base __ios_base; typedef typename __istream_type::int_type __int_type; typedef typename __string_type::size_type __size_type; typedef ctype<_CharT> __ctype_type; typedef typename __ctype_type::ctype_base __ctype_base; __size_type __extracted = 0; typename __ios_base::iostate __err = __ios_base::goodbit; typename __istream_type::sentry __cerb(__in, false); if (__cerb) { try { __str.erase(); _CharT __buf[128]; __size_type __len = 0; const streamsize __w = __in.width(); const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size(); const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); const __int_type __eof = _Traits::eof(); __int_type __c = __in.rdbuf()->sgetc(); while (__extracted < __n && !_Traits::eq_int_type(__c, __eof) && !__ct.is(__ctype_base::space, _Traits::to_char_type(__c))) { if (__len == sizeof(__buf) / sizeof(_CharT)) { __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); __len = 0; } __buf[__len++] = _Traits::to_char_type(__c); ++__extracted; __c = __in.rdbuf()->snextc(); } __str.append(__buf, __len); if (_Traits::eq_int_type(__c, __eof)) __err |= __ios_base::eofbit; __in.width(0); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(__ios_base::badbit); throw; } catch(...) { __in._M_setstate(__ios_base::badbit); } } if (!__extracted) __err |= __ios_base::failbit; if (__err) __in.setstate(__err); return __in; } template basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __in, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __istream_type::ios_base __ios_base; typedef typename __istream_type::int_type __int_type; typedef typename __string_type::size_type __size_type; __size_type __extracted = 0; const __size_type __n = __str.max_size(); typename __ios_base::iostate __err = __ios_base::goodbit; typename __istream_type::sentry __cerb(__in, true); if (__cerb) { try { __str.erase(); const __int_type __idelim = _Traits::to_int_type(__delim); const __int_type __eof = _Traits::eof(); __int_type __c = __in.rdbuf()->sgetc(); while (__extracted < __n && !_Traits::eq_int_type(__c, __eof) && !_Traits::eq_int_type(__c, __idelim)) { __str += _Traits::to_char_type(__c); ++__extracted; __c = __in.rdbuf()->snextc(); } if (_Traits::eq_int_type(__c, __eof)) __err |= __ios_base::eofbit; else if (_Traits::eq_int_type(__c, __idelim)) { ++__extracted; __in.rdbuf()->sbumpc(); } else __err |= __ios_base::failbit; } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(__ios_base::badbit); throw; } catch(...) { __in._M_setstate(__ios_base::badbit); } } if (!__extracted) __err |= __ios_base::failbit; if (__err) __in.setstate(__err); return __in; } # 1618 "/usr/include/c++/10/bits/basic_string.tcc" 3 extern template basic_istream& operator>>(basic_istream&, string&); extern template basic_ostream& operator<<(basic_ostream&, const string&); extern template basic_istream& getline(basic_istream&, string&, char); extern template basic_istream& getline(basic_istream&, string&); # 1639 "/usr/include/c++/10/bits/basic_string.tcc" 3 extern template basic_istream& operator>>(basic_istream&, wstring&); extern template basic_ostream& operator<<(basic_ostream&, const wstring&); extern template basic_istream& getline(basic_istream&, wstring&, wchar_t); extern template basic_istream& getline(basic_istream&, wstring&); } # 57 "/usr/include/c++/10/string" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template> using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>; using string = basic_string; using u8string = basic_string; using u16string = basic_string; using u32string = basic_string; using wstring = basic_string; } template struct __hash_string_base : public __hash_base { size_t operator()(const _Str& __s) const noexcept { return hash>{}(__s); } }; template<> struct hash : public __hash_string_base { }; template<> struct hash : public __hash_string_base { }; template<> struct hash : public __hash_string_base { }; template<> struct hash : public __hash_string_base { }; template<> struct hash : public __hash_string_base { }; } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename basic_string<_CharT, _Traits, _Alloc>::size_type erase_if(basic_string<_CharT, _Traits, _Alloc>& __cont, _Predicate __pred) { const auto __osz = __cont.size(); __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred), __cont.end()); return __osz - __cont.size(); } template inline typename basic_string<_CharT, _Traits, _Alloc>::size_type erase(basic_string<_CharT, _Traits, _Alloc>& __cont, const _Up& __value) { const auto __osz = __cont.size(); __cont.erase(std::remove(__cont.begin(), __cont.end(), __value), __cont.end()); return __osz - __cont.size(); } } # 48 "/usr/include/c++/10/bitset" 2 3 # 64 "/usr/include/c++/10/bitset" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct _Base_bitset { typedef unsigned long _WordT; _WordT _M_w[_Nw]; constexpr _Base_bitset() noexcept : _M_w() { } constexpr _Base_bitset(unsigned long long __val) noexcept : _M_w{ _WordT(__val) } { } static constexpr size_t _S_whichword(size_t __pos) noexcept { return __pos / (8 * 8); } static constexpr size_t _S_whichbyte(size_t __pos) noexcept { return (__pos % (8 * 8)) / 8; } static constexpr size_t _S_whichbit(size_t __pos) noexcept { return __pos % (8 * 8); } static constexpr _WordT _S_maskbit(size_t __pos) noexcept { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t __pos) noexcept { return _M_w[_S_whichword(__pos)]; } constexpr _WordT _M_getword(size_t __pos) const noexcept { return _M_w[_S_whichword(__pos)]; } const _WordT* _M_getdata() const noexcept { return _M_w; } _WordT& _M_hiword() noexcept { return _M_w[_Nw - 1]; } constexpr _WordT _M_hiword() const noexcept { return _M_w[_Nw - 1]; } void _M_do_and(const _Base_bitset<_Nw>& __x) noexcept { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] &= __x._M_w[__i]; } void _M_do_or(const _Base_bitset<_Nw>& __x) noexcept { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] |= __x._M_w[__i]; } void _M_do_xor(const _Base_bitset<_Nw>& __x) noexcept { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] ^= __x._M_w[__i]; } void _M_do_left_shift(size_t __shift) noexcept; void _M_do_right_shift(size_t __shift) noexcept; void _M_do_flip() noexcept { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] = ~_M_w[__i]; } void _M_do_set() noexcept { for (size_t __i = 0; __i < _Nw; __i++) _M_w[__i] = ~static_cast<_WordT>(0); } void _M_do_reset() noexcept { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); } bool _M_is_equal(const _Base_bitset<_Nw>& __x) const noexcept { for (size_t __i = 0; __i < _Nw; ++__i) if (_M_w[__i] != __x._M_w[__i]) return false; return true; } template bool _M_are_all() const noexcept { for (size_t __i = 0; __i < _Nw - 1; __i++) if (_M_w[__i] != ~static_cast<_WordT>(0)) return false; return _M_hiword() == (~static_cast<_WordT>(0) >> (_Nw * (8 * 8) - _Nb)); } bool _M_is_any() const noexcept { for (size_t __i = 0; __i < _Nw; __i++) if (_M_w[__i] != static_cast<_WordT>(0)) return true; return false; } size_t _M_do_count() const noexcept { size_t __result = 0; for (size_t __i = 0; __i < _Nw; __i++) __result += __builtin_popcountl(_M_w[__i]); return __result; } unsigned long _M_do_to_ulong() const; unsigned long long _M_do_to_ullong() const; size_t _M_do_find_first(size_t) const noexcept; size_t _M_do_find_next(size_t, size_t) const noexcept; }; template void _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) noexcept { if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / (8 * 8); const size_t __offset = __shift % (8 * 8); if (__offset == 0) for (size_t __n = _Nw - 1; __n >= __wshift; --__n) _M_w[__n] = _M_w[__n - __wshift]; else { const size_t __sub_offset = ((8 * 8) - __offset); for (size_t __n = _Nw - 1; __n > __wshift; --__n) _M_w[__n] = ((_M_w[__n - __wshift] << __offset) | (_M_w[__n - __wshift - 1] >> __sub_offset)); _M_w[__wshift] = _M_w[0] << __offset; } std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0)); } } template void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) noexcept { if (__builtin_expect(__shift != 0, 1)) { const size_t __wshift = __shift / (8 * 8); const size_t __offset = __shift % (8 * 8); const size_t __limit = _Nw - __wshift - 1; if (__offset == 0) for (size_t __n = 0; __n <= __limit; ++__n) _M_w[__n] = _M_w[__n + __wshift]; else { const size_t __sub_offset = ((8 * 8) - __offset); for (size_t __n = 0; __n < __limit; ++__n) _M_w[__n] = ((_M_w[__n + __wshift] >> __offset) | (_M_w[__n + __wshift + 1] << __sub_offset)); _M_w[__limit] = _M_w[_Nw-1] >> __offset; } std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); } } template unsigned long _Base_bitset<_Nw>::_M_do_to_ulong() const { for (size_t __i = 1; __i < _Nw; ++__i) if (_M_w[__i]) __throw_overflow_error(("_Base_bitset::_M_do_to_ulong")); return _M_w[0]; } template unsigned long long _Base_bitset<_Nw>::_M_do_to_ullong() const { const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long); for (size_t __i = 1 + __dw; __i < _Nw; ++__i) if (_M_w[__i]) __throw_overflow_error(("_Base_bitset::_M_do_to_ullong")); if (__dw) return _M_w[0] + (static_cast(_M_w[1]) << (8 * 8)); return _M_w[0]; } template size_t _Base_bitset<_Nw>:: _M_do_find_first(size_t __not_found) const noexcept { for (size_t __i = 0; __i < _Nw; __i++) { _WordT __thisword = _M_w[__i]; if (__thisword != static_cast<_WordT>(0)) return (__i * (8 * 8) + __builtin_ctzl(__thisword)); } return __not_found; } template size_t _Base_bitset<_Nw>:: _M_do_find_next(size_t __prev, size_t __not_found) const noexcept { ++__prev; if (__prev >= _Nw * (8 * 8)) return __not_found; size_t __i = _S_whichword(__prev); _WordT __thisword = _M_w[__i]; __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); if (__thisword != static_cast<_WordT>(0)) return (__i * (8 * 8) + __builtin_ctzl(__thisword)); __i++; for (; __i < _Nw; __i++) { __thisword = _M_w[__i]; if (__thisword != static_cast<_WordT>(0)) return (__i * (8 * 8) + __builtin_ctzl(__thisword)); } return __not_found; } template<> struct _Base_bitset<1> { typedef unsigned long _WordT; _WordT _M_w; constexpr _Base_bitset() noexcept : _M_w(0) { } constexpr _Base_bitset(unsigned long long __val) noexcept : _M_w(__val) { } static constexpr size_t _S_whichword(size_t __pos) noexcept { return __pos / (8 * 8); } static constexpr size_t _S_whichbyte(size_t __pos) noexcept { return (__pos % (8 * 8)) / 8; } static constexpr size_t _S_whichbit(size_t __pos) noexcept { return __pos % (8 * 8); } static constexpr _WordT _S_maskbit(size_t __pos) noexcept { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t) noexcept { return _M_w; } constexpr _WordT _M_getword(size_t) const noexcept { return _M_w; } const _WordT* _M_getdata() const noexcept { return &_M_w; } _WordT& _M_hiword() noexcept { return _M_w; } constexpr _WordT _M_hiword() const noexcept { return _M_w; } void _M_do_and(const _Base_bitset<1>& __x) noexcept { _M_w &= __x._M_w; } void _M_do_or(const _Base_bitset<1>& __x) noexcept { _M_w |= __x._M_w; } void _M_do_xor(const _Base_bitset<1>& __x) noexcept { _M_w ^= __x._M_w; } void _M_do_left_shift(size_t __shift) noexcept { _M_w <<= __shift; } void _M_do_right_shift(size_t __shift) noexcept { _M_w >>= __shift; } void _M_do_flip() noexcept { _M_w = ~_M_w; } void _M_do_set() noexcept { _M_w = ~static_cast<_WordT>(0); } void _M_do_reset() noexcept { _M_w = 0; } bool _M_is_equal(const _Base_bitset<1>& __x) const noexcept { return _M_w == __x._M_w; } template bool _M_are_all() const noexcept { return _M_w == (~static_cast<_WordT>(0) >> ((8 * 8) - _Nb)); } bool _M_is_any() const noexcept { return _M_w != 0; } size_t _M_do_count() const noexcept { return __builtin_popcountl(_M_w); } unsigned long _M_do_to_ulong() const noexcept { return _M_w; } unsigned long long _M_do_to_ullong() const noexcept { return _M_w; } size_t _M_do_find_first(size_t __not_found) const noexcept { if (_M_w != 0) return __builtin_ctzl(_M_w); else return __not_found; } size_t _M_do_find_next(size_t __prev, size_t __not_found) const noexcept { ++__prev; if (__prev >= ((size_t) (8 * 8))) return __not_found; _WordT __x = _M_w >> __prev; if (__x != 0) return __builtin_ctzl(__x) + __prev; else return __not_found; } }; template<> struct _Base_bitset<0> { typedef unsigned long _WordT; constexpr _Base_bitset() noexcept { } constexpr _Base_bitset(unsigned long long) noexcept { } static constexpr size_t _S_whichword(size_t __pos) noexcept { return __pos / (8 * 8); } static constexpr size_t _S_whichbyte(size_t __pos) noexcept { return (__pos % (8 * 8)) / 8; } static constexpr size_t _S_whichbit(size_t __pos) noexcept { return __pos % (8 * 8); } static constexpr _WordT _S_maskbit(size_t __pos) noexcept { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } # 560 "/usr/include/c++/10/bitset" 3 _WordT& _M_getword(size_t) noexcept { __throw_out_of_range(("_Base_bitset::_M_getword")); return *new _WordT; } constexpr _WordT _M_getword(size_t) const noexcept { return 0; } constexpr _WordT _M_hiword() const noexcept { return 0; } void _M_do_and(const _Base_bitset<0>&) noexcept { } void _M_do_or(const _Base_bitset<0>&) noexcept { } void _M_do_xor(const _Base_bitset<0>&) noexcept { } void _M_do_left_shift(size_t) noexcept { } void _M_do_right_shift(size_t) noexcept { } void _M_do_flip() noexcept { } void _M_do_set() noexcept { } void _M_do_reset() noexcept { } bool _M_is_equal(const _Base_bitset<0>&) const noexcept { return true; } template bool _M_are_all() const noexcept { return true; } bool _M_is_any() const noexcept { return false; } size_t _M_do_count() const noexcept { return 0; } unsigned long _M_do_to_ulong() const noexcept { return 0; } unsigned long long _M_do_to_ullong() const noexcept { return 0; } size_t _M_do_find_first(size_t) const noexcept { return 0; } size_t _M_do_find_next(size_t, size_t) const noexcept { return 0; } }; template struct _Sanitize { typedef unsigned long _WordT; static void _S_do_sanitize(_WordT& __val) noexcept { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); } }; template<> struct _Sanitize<0> { typedef unsigned long _WordT; static void _S_do_sanitize(_WordT) noexcept { } }; template struct _Sanitize_val { static constexpr unsigned long long _S_do_sanitize_val(unsigned long long __val) { return __val; } }; template struct _Sanitize_val<_Nb, true> { static constexpr unsigned long long _S_do_sanitize_val(unsigned long long __val) { return __val & ~((~static_cast(0)) << _Nb); } }; # 750 "/usr/include/c++/10/bitset" 3 template class bitset : private _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> { private: typedef _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> _Base; typedef unsigned long _WordT; template void _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position) const { if (__position > __s.size()) __throw_out_of_range_fmt(("bitset::bitset: __position " "(which is %zu) > __s.size() " "(which is %zu)") , __position, __s.size()); } void _M_check(size_t __position, const char *__s) const { if (__position >= _Nb) __throw_out_of_range_fmt(("%s: __position (which is %zu) " ">= _Nb (which is %zu)") , __s, __position, _Nb); } void _M_do_sanitize() noexcept { typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type; __sanitize_type::_S_do_sanitize(this->_M_hiword()); } friend struct std::hash; public: # 802 "/usr/include/c++/10/bitset" 3 class reference { friend class bitset; _WordT* _M_wp; size_t _M_bpos; reference(); public: reference(bitset& __b, size_t __pos) noexcept { _M_wp = &__b._M_getword(__pos); _M_bpos = _Base::_S_whichbit(__pos); } reference(const reference&) = default; ~reference() noexcept { } reference& operator=(bool __x) noexcept { if (__x) *_M_wp |= _Base::_S_maskbit(_M_bpos); else *_M_wp &= ~_Base::_S_maskbit(_M_bpos); return *this; } reference& operator=(const reference& __j) noexcept { if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos))) *_M_wp |= _Base::_S_maskbit(_M_bpos); else *_M_wp &= ~_Base::_S_maskbit(_M_bpos); return *this; } bool operator~() const noexcept { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; } operator bool() const noexcept { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; } reference& flip() noexcept { *_M_wp ^= _Base::_S_maskbit(_M_bpos); return *this; } }; friend class reference; constexpr bitset() noexcept { } constexpr bitset(unsigned long long __val) noexcept : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { } # 891 "/usr/include/c++/10/bitset" 3 template explicit bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position = 0) : _Base() { _M_check_initial_position(__s, __position); _M_copy_from_string(__s, __position, std::basic_string<_CharT, _Traits, _Alloc>::npos, _CharT('0'), _CharT('1')); } # 913 "/usr/include/c++/10/bitset" 3 template bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position, size_t __n) : _Base() { _M_check_initial_position(__s, __position); _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1')); } template bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position, size_t __n, _CharT __zero, _CharT __one = _CharT('1')) : _Base() { _M_check_initial_position(__s, __position); _M_copy_from_string(__s, __position, __n, __zero, __one); } # 944 "/usr/include/c++/10/bitset" 3 template explicit bitset(const _CharT* __str, typename std::basic_string<_CharT>::size_type __n = std::basic_string<_CharT>::npos, _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) : _Base() { if (!__str) __throw_logic_error(("bitset::bitset(const _CharT*, ...)")); if (__n == std::basic_string<_CharT>::npos) __n = std::char_traits<_CharT>::length(__str); _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0, __n, __zero, __one); } # 971 "/usr/include/c++/10/bitset" 3 bitset<_Nb>& operator&=(const bitset<_Nb>& __rhs) noexcept { this->_M_do_and(__rhs); return *this; } bitset<_Nb>& operator|=(const bitset<_Nb>& __rhs) noexcept { this->_M_do_or(__rhs); return *this; } bitset<_Nb>& operator^=(const bitset<_Nb>& __rhs) noexcept { this->_M_do_xor(__rhs); return *this; } # 1000 "/usr/include/c++/10/bitset" 3 bitset<_Nb>& operator<<=(size_t __position) noexcept { if (__builtin_expect(__position < _Nb, 1)) { this->_M_do_left_shift(__position); this->_M_do_sanitize(); } else this->_M_do_reset(); return *this; } bitset<_Nb>& operator>>=(size_t __position) noexcept { if (__builtin_expect(__position < _Nb, 1)) { this->_M_do_right_shift(__position); this->_M_do_sanitize(); } else this->_M_do_reset(); return *this; } # 1033 "/usr/include/c++/10/bitset" 3 bitset<_Nb>& _Unchecked_set(size_t __pos) noexcept { this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); return *this; } bitset<_Nb>& _Unchecked_set(size_t __pos, int __val) noexcept { if (__val) this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); else this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); return *this; } bitset<_Nb>& _Unchecked_reset(size_t __pos) noexcept { this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); return *this; } bitset<_Nb>& _Unchecked_flip(size_t __pos) noexcept { this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos); return *this; } constexpr bool _Unchecked_test(size_t __pos) const noexcept { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) != static_cast<_WordT>(0)); } bitset<_Nb>& set() noexcept { this->_M_do_set(); this->_M_do_sanitize(); return *this; } bitset<_Nb>& set(size_t __position, bool __val = true) { this->_M_check(__position, ("bitset::set")); return _Unchecked_set(__position, __val); } bitset<_Nb>& reset() noexcept { this->_M_do_reset(); return *this; } # 1112 "/usr/include/c++/10/bitset" 3 bitset<_Nb>& reset(size_t __position) { this->_M_check(__position, ("bitset::reset")); return _Unchecked_reset(__position); } bitset<_Nb>& flip() noexcept { this->_M_do_flip(); this->_M_do_sanitize(); return *this; } bitset<_Nb>& flip(size_t __position) { this->_M_check(__position, ("bitset::flip")); return _Unchecked_flip(__position); } bitset<_Nb> operator~() const noexcept { return bitset<_Nb>(*this).flip(); } # 1162 "/usr/include/c++/10/bitset" 3 reference operator[](size_t __position) { return reference(*this, __position); } constexpr bool operator[](size_t __position) const { return _Unchecked_test(__position); } # 1177 "/usr/include/c++/10/bitset" 3 unsigned long to_ulong() const { return this->_M_do_to_ulong(); } unsigned long long to_ullong() const { return this->_M_do_to_ullong(); } # 1195 "/usr/include/c++/10/bitset" 3 template std::basic_string<_CharT, _Traits, _Alloc> to_string() const { std::basic_string<_CharT, _Traits, _Alloc> __result; _M_copy_to_string(__result, _CharT('0'), _CharT('1')); return __result; } template std::basic_string<_CharT, _Traits, _Alloc> to_string(_CharT __zero, _CharT __one = _CharT('1')) const { std::basic_string<_CharT, _Traits, _Alloc> __result; _M_copy_to_string(__result, __zero, __one); return __result; } template std::basic_string<_CharT, _Traits, std::allocator<_CharT> > to_string() const { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } template std::basic_string<_CharT, _Traits, std::allocator<_CharT> > to_string(_CharT __zero, _CharT __one = _CharT('1')) const { return to_string<_CharT, _Traits, std::allocator<_CharT> >(__zero, __one); } template std::basic_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> > to_string() const { return to_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> >(); } template std::basic_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> > to_string(_CharT __zero, _CharT __one = _CharT('1')) const { return to_string<_CharT, std::char_traits<_CharT>, std::allocator<_CharT> >(__zero, __one); } std::basic_string, std::allocator > to_string() const { return to_string, std::allocator >(); } std::basic_string, std::allocator > to_string(char __zero, char __one = '1') const { return to_string, std::allocator >(__zero, __one); } template void _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t, _CharT, _CharT); template void _M_copy_from_string(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __pos, size_t __n, _CharT __zero, _CharT __one) { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n, __zero, __one); } template void _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&, _CharT, _CharT) const; template void _M_copy_from_string(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __pos, size_t __n) { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); } template void _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); } size_t count() const noexcept { return this->_M_do_count(); } constexpr size_t size() const noexcept { return _Nb; } bool operator==(const bitset<_Nb>& __rhs) const noexcept { return this->_M_is_equal(__rhs); } # 1322 "/usr/include/c++/10/bitset" 3 bool test(size_t __position) const { this->_M_check(__position, ("bitset::test")); return _Unchecked_test(__position); } bool all() const noexcept { return this->template _M_are_all<_Nb>(); } bool any() const noexcept { return this->_M_is_any(); } bool none() const noexcept { return !this->_M_is_any(); } bitset<_Nb> operator<<(size_t __position) const noexcept { return bitset<_Nb>(*this) <<= __position; } bitset<_Nb> operator>>(size_t __position) const noexcept { return bitset<_Nb>(*this) >>= __position; } # 1372 "/usr/include/c++/10/bitset" 3 size_t _Find_first() const noexcept { return this->_M_do_find_first(_Nb); } # 1383 "/usr/include/c++/10/bitset" 3 size_t _Find_next(size_t __prev) const noexcept { return this->_M_do_find_next(__prev, _Nb); } }; template template void bitset<_Nb>:: _M_copy_from_ptr(const _CharT* __s, size_t __len, size_t __pos, size_t __n, _CharT __zero, _CharT __one) { reset(); const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos))); for (size_t __i = __nbits; __i > 0; --__i) { const _CharT __c = __s[__pos + __nbits - __i]; if (_Traits::eq(__c, __zero)) ; else if (_Traits::eq(__c, __one)) _Unchecked_set(__i - 1); else __throw_invalid_argument(("bitset::_M_copy_from_ptr")); } } template template void bitset<_Nb>:: _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s, _CharT __zero, _CharT __one) const { __s.assign(_Nb, __zero); for (size_t __i = _Nb; __i > 0; --__i) if (_Unchecked_test(__i - 1)) _Traits::assign(__s[_Nb - __i], __one); } # 1433 "/usr/include/c++/10/bitset" 3 template inline bitset<_Nb> operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept { bitset<_Nb> __result(__x); __result &= __y; return __result; } template inline bitset<_Nb> operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept { bitset<_Nb> __result(__x); __result |= __y; return __result; } template inline bitset<_Nb> operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept { bitset<_Nb> __result(__x); __result ^= __y; return __result; } # 1470 "/usr/include/c++/10/bitset" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) { typedef typename _Traits::char_type char_type; typedef std::basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::ios_base __ios_base; std::basic_string<_CharT, _Traits> __tmp; __tmp.reserve(_Nb); const char_type __zero = __is.widen('0'); const char_type __one = __is.widen('1'); typename __ios_base::iostate __state = __ios_base::goodbit; typename __istream_type::sentry __sentry(__is); if (__sentry) { try { for (size_t __i = _Nb; __i > 0; --__i) { static typename _Traits::int_type __eof = _Traits::eof(); typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); if (_Traits::eq_int_type(__c1, __eof)) { __state |= __ios_base::eofbit; break; } else { const char_type __c2 = _Traits::to_char_type(__c1); if (_Traits::eq(__c2, __zero)) __tmp.push_back(__zero); else if (_Traits::eq(__c2, __one)) __tmp.push_back(__one); else if (_Traits:: eq_int_type(__is.rdbuf()->sputbackc(__c2), __eof)) { __state |= __ios_base::failbit; break; } } } } catch(__cxxabiv1::__forced_unwind&) { __is._M_setstate(__ios_base::badbit); throw; } catch(...) { __is._M_setstate(__ios_base::badbit); } } if (__tmp.empty() && _Nb) __state |= __ios_base::failbit; else __x._M_copy_from_string(__tmp, static_cast(0), _Nb, __zero, __one); if (__state) __is.setstate(__state); return __is; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x) { std::basic_string<_CharT, _Traits> __tmp; const ctype<_CharT>& __ct = use_facet >(__os.getloc()); __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1')); return __os << __tmp; } } namespace std __attribute__ ((__visibility__ ("default"))) { template struct hash> : public __hash_base> { size_t operator()(const std::bitset<_Nb>& __b) const noexcept { const size_t __clength = (_Nb + 8 - 1) / 8; return std::_Hash_impl::hash(__b._M_getdata(), __clength); } }; template<> struct hash> : public __hash_base> { size_t operator()(const std::bitset<0>&) const noexcept { return 0; } }; } # 13 "all-std.cxx" 2 # 1 "/usr/include/c++/10/chrono" 1 3 # 33 "/usr/include/c++/10/chrono" 3 # 34 "/usr/include/c++/10/chrono" 3 # 1 "/usr/include/c++/10/ratio" 1 3 # 33 "/usr/include/c++/10/ratio" 3 # 34 "/usr/include/c++/10/ratio" 3 # 42 "/usr/include/c++/10/ratio" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 56 "/usr/include/c++/10/ratio" 3 template struct __static_sign : integral_constant { }; template struct __static_abs : integral_constant::value> { }; template struct __static_gcd : __static_gcd<_Qn, (_Pn % _Qn)> { }; template struct __static_gcd<_Pn, 0> : integral_constant::value> { }; template struct __static_gcd<0, _Qn> : integral_constant::value> { }; template struct __safe_multiply { private: static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4); static const uintmax_t __a0 = __static_abs<_Pn>::value % __c; static const uintmax_t __a1 = __static_abs<_Pn>::value / __c; static const uintmax_t __b0 = __static_abs<_Qn>::value % __c; static const uintmax_t __b1 = __static_abs<_Qn>::value / __c; static_assert(__a1 == 0 || __b1 == 0, "overflow in multiplication"); static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), "overflow in multiplication"); static_assert(__b0 * __a0 <= 0x7fffffffffffffffL, "overflow in multiplication"); static_assert((__a0 * __b1 + __b0 * __a1) * __c <= 0x7fffffffffffffffL - __b0 * __a0, "overflow in multiplication"); public: static const intmax_t value = _Pn * _Qn; }; template struct __big_less : integral_constant { }; template struct __big_add { static constexpr uintmax_t __lo = __lo1 + __lo2; static constexpr uintmax_t __hi = (__hi1 + __hi2 + (__lo1 + __lo2 < __lo1)); }; template struct __big_sub { static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value, "Internal library error"); static constexpr uintmax_t __lo = __lo1 - __lo2; static constexpr uintmax_t __hi = (__hi1 - __hi2 - (__lo1 < __lo2)); }; template struct __big_mul { private: static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4); static constexpr uintmax_t __x0 = __x % __c; static constexpr uintmax_t __x1 = __x / __c; static constexpr uintmax_t __y0 = __y % __c; static constexpr uintmax_t __y1 = __y / __c; static constexpr uintmax_t __x0y0 = __x0 * __y0; static constexpr uintmax_t __x0y1 = __x0 * __y1; static constexpr uintmax_t __x1y0 = __x1 * __y0; static constexpr uintmax_t __x1y1 = __x1 * __y1; static constexpr uintmax_t __mix = __x0y1 + __x1y0; static constexpr uintmax_t __mix_lo = __mix * __c; static constexpr uintmax_t __mix_hi = __mix / __c + ((__mix < __x0y1) ? __c : 0); typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res; public: static constexpr uintmax_t __hi = _Res::__hi; static constexpr uintmax_t __lo = _Res::__lo; }; template struct __big_div_impl { private: static_assert(__d >= (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)), "Internal library error"); static_assert(__n1 < __d, "Internal library error"); static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4); static constexpr uintmax_t __d1 = __d / __c; static constexpr uintmax_t __d0 = __d % __c; static constexpr uintmax_t __q1x = __n1 / __d1; static constexpr uintmax_t __r1x = __n1 % __d1; static constexpr uintmax_t __m = __q1x * __d0; static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c; static constexpr uintmax_t __r1z = __r1y + __d; static constexpr uintmax_t __r1 = ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m)) ? (__r1z + __d) : __r1z : __r1y) - __m; static constexpr uintmax_t __q1 = __q1x - ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0); static constexpr uintmax_t __q0x = __r1 / __d1; static constexpr uintmax_t __r0x = __r1 % __d1; static constexpr uintmax_t __n = __q0x * __d0; static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c; static constexpr uintmax_t __r0z = __r0y + __d; static constexpr uintmax_t __r0 = ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n)) ? (__r0z + __d) : __r0z : __r0y) - __n; static constexpr uintmax_t __q0 = __q0x - ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n)) ? 2 : 1 : 0); public: static constexpr uintmax_t __quot = __q1 * __c + __q0; static constexpr uintmax_t __rem = __r0; private: typedef __big_mul<__quot, __d> _Prod; typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum; static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0, "Internal library error"); }; template struct __big_div { private: static_assert(__d != 0, "Internal library error"); static_assert(sizeof (uintmax_t) == sizeof (unsigned long long), "This library calls __builtin_clzll on uintmax_t, which " "is unsafe on your platform. Please complain to " "http://gcc.gnu.org/bugzilla/"); static constexpr int __shift = __builtin_clzll(__d); static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift; static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0; static constexpr uintmax_t __c1 = uintmax_t(1) << __shift; static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift; static constexpr uintmax_t __new_d = __d * __c1; static constexpr uintmax_t __new_n0 = __n0 * __c1; static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1; static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0; static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top; typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res; public: static constexpr uintmax_t __quot_hi = __n1 / __d; static constexpr uintmax_t __quot_lo = _Res::__quot; static constexpr uintmax_t __rem = _Res::__rem / __c1; private: typedef __big_mul<__quot_lo, __d> _P0; typedef __big_mul<__quot_hi, __d> _P1; typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum; static_assert(_P1::__hi == 0, "Internal library error"); static_assert(_Sum::__hi >= _P0::__hi, "Internal library error"); static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0, "Internal library error"); static_assert(__rem < __d, "Internal library error"); }; # 265 "/usr/include/c++/10/ratio" 3 template struct ratio { static_assert(_Den != 0, "denominator cannot be zero"); static_assert(_Num >= -0x7fffffffffffffffL && _Den >= -0x7fffffffffffffffL, "out of range"); static constexpr intmax_t num = _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value; static constexpr intmax_t den = __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value; typedef ratio type; }; template constexpr intmax_t ratio<_Num, _Den>::num; template constexpr intmax_t ratio<_Num, _Den>::den; template struct __ratio_multiply { private: static const intmax_t __gcd1 = __static_gcd<_R1::num, _R2::den>::value; static const intmax_t __gcd2 = __static_gcd<_R2::num, _R1::den>::value; public: typedef ratio< __safe_multiply<(_R1::num / __gcd1), (_R2::num / __gcd2)>::value, __safe_multiply<(_R1::den / __gcd2), (_R2::den / __gcd1)>::value> type; static constexpr intmax_t num = type::num; static constexpr intmax_t den = type::den; }; template constexpr intmax_t __ratio_multiply<_R1, _R2>::num; template constexpr intmax_t __ratio_multiply<_R1, _R2>::den; template using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type; template struct __ratio_divide { static_assert(_R2::num != 0, "division by 0"); typedef typename __ratio_multiply< _R1, ratio<_R2::den, _R2::num>>::type type; static constexpr intmax_t num = type::num; static constexpr intmax_t den = type::den; }; template constexpr intmax_t __ratio_divide<_R1, _R2>::num; template constexpr intmax_t __ratio_divide<_R1, _R2>::den; template using ratio_divide = typename __ratio_divide<_R1, _R2>::type; template struct ratio_equal : integral_constant { }; template struct ratio_not_equal : integral_constant::value> { }; template, typename _Right = __big_mul<_R2::num,_R1::den> > struct __ratio_less_impl_1 : integral_constant::value> { }; template::value != __static_sign<_R2::num>::value)), bool = (__static_sign<_R1::num>::value == -1 && __static_sign<_R2::num>::value == -1)> struct __ratio_less_impl : __ratio_less_impl_1<_R1, _R2>::type { }; template struct __ratio_less_impl<_R1, _R2, true, false> : integral_constant { }; template struct __ratio_less_impl<_R1, _R2, false, true> : __ratio_less_impl_1, ratio<-_R1::num, _R1::den> >::type { }; template struct ratio_less : __ratio_less_impl<_R1, _R2>::type { }; template struct ratio_less_equal : integral_constant::value> { }; template struct ratio_greater : integral_constant::value> { }; template struct ratio_greater_equal : integral_constant::value> { }; template inline constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value; template inline constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value; template inline constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value; template inline constexpr bool ratio_less_equal_v = ratio_less_equal<_R1, _R2>::value; template inline constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value; template inline constexpr bool ratio_greater_equal_v = ratio_greater_equal<_R1, _R2>::value; template= 0), bool = (_R2::num >= 0), bool = ratio_less::value, _R1::den>, ratio<__static_abs<_R2::num>::value, _R2::den> >::value> struct __ratio_add_impl { private: typedef typename __ratio_add_impl< ratio<-_R1::num, _R1::den>, ratio<-_R2::num, _R2::den> >::type __t; public: typedef ratio<-__t::num, __t::den> type; }; template struct __ratio_add_impl<_R1, _R2, true, true, __b> { private: static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value; static constexpr uintmax_t __d2 = _R2::den / __g; typedef __big_mul<_R1::den, __d2> __d; typedef __big_mul<_R1::num, _R2::den / __g> __x; typedef __big_mul<_R2::num, _R1::den / __g> __y; typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n; static_assert(__n::__hi >= __x::__hi, "Internal library error"); typedef __big_div<__n::__hi, __n::__lo, __g> __ng; static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value; typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final; static_assert(__n_final::__rem == 0, "Internal library error"); static_assert(__n_final::__quot_hi == 0 && __n_final::__quot_lo <= 0x7fffffffffffffffL, "overflow in addition"); typedef __big_mul<_R1::den / __g2, __d2> __d_final; static_assert(__d_final::__hi == 0 && __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition"); public: typedef ratio<__n_final::__quot_lo, __d_final::__lo> type; }; template struct __ratio_add_impl<_R1, _R2, false, true, true> : __ratio_add_impl<_R2, _R1> { }; template struct __ratio_add_impl<_R1, _R2, true, false, false> { private: static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value; static constexpr uintmax_t __d2 = _R2::den / __g; typedef __big_mul<_R1::den, __d2> __d; typedef __big_mul<_R1::num, _R2::den / __g> __x; typedef __big_mul<-_R2::num, _R1::den / __g> __y; typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n; typedef __big_div<__n::__hi, __n::__lo, __g> __ng; static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value; typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final; static_assert(__n_final::__rem == 0, "Internal library error"); static_assert(__n_final::__quot_hi == 0 && __n_final::__quot_lo <= 0x7fffffffffffffffL, "overflow in addition"); typedef __big_mul<_R1::den / __g2, __d2> __d_final; static_assert(__d_final::__hi == 0 && __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition"); public: typedef ratio<__n_final::__quot_lo, __d_final::__lo> type; }; template struct __ratio_add { typedef typename __ratio_add_impl<_R1, _R2>::type type; static constexpr intmax_t num = type::num; static constexpr intmax_t den = type::den; }; template constexpr intmax_t __ratio_add<_R1, _R2>::num; template constexpr intmax_t __ratio_add<_R1, _R2>::den; template using ratio_add = typename __ratio_add<_R1, _R2>::type; template struct __ratio_subtract { typedef typename __ratio_add< _R1, ratio<-_R2::num, _R2::den>>::type type; static constexpr intmax_t num = type::num; static constexpr intmax_t den = type::den; }; template constexpr intmax_t __ratio_subtract<_R1, _R2>::num; template constexpr intmax_t __ratio_subtract<_R1, _R2>::den; template using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type; typedef ratio<1, 1000000000000000000> atto; typedef ratio<1, 1000000000000000> femto; typedef ratio<1, 1000000000000> pico; typedef ratio<1, 1000000000> nano; typedef ratio<1, 1000000> micro; typedef ratio<1, 1000> milli; typedef ratio<1, 100> centi; typedef ratio<1, 10> deci; typedef ratio< 10, 1> deca; typedef ratio< 100, 1> hecto; typedef ratio< 1000, 1> kilo; typedef ratio< 1000000, 1> mega; typedef ratio< 1000000000, 1> giga; typedef ratio< 1000000000000, 1> tera; typedef ratio< 1000000000000000, 1> peta; typedef ratio< 1000000000000000000, 1> exa; } # 40 "/usr/include/c++/10/chrono" 2 3 # 1 "/usr/include/c++/10/ctime" 1 3 # 39 "/usr/include/c++/10/ctime" 3 # 40 "/usr/include/c++/10/ctime" 3 # 58 "/usr/include/c++/10/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; } namespace std { using ::timespec; using ::timespec_get; } # 43 "/usr/include/c++/10/chrono" 2 3 # 1 "/usr/include/c++/10/bits/parse_numbers.h" 1 3 # 33 "/usr/include/c++/10/bits/parse_numbers.h" 3 # 34 "/usr/include/c++/10/bits/parse_numbers.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __parse_int { template struct _Digit; template struct _Digit<_Base, '0'> : integral_constant { using __valid = true_type; }; template struct _Digit<_Base, '1'> : integral_constant { using __valid = true_type; }; template struct _Digit_impl : integral_constant { static_assert(_Base > _Val, "invalid digit"); using __valid = true_type; }; template struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2> { }; template struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3> { }; template struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4> { }; template struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5> { }; template struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6> { }; template struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7> { }; template struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8> { }; template struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9> { }; template struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa> { }; template struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa> { }; template struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb> { }; template struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb> { }; template struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc> { }; template struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc> { }; template struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd> { }; template struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd> { }; template struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe> { }; template struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe> { }; template struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf> { }; template struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf> { }; template struct _Digit<_Base, '\''> : integral_constant { using __valid = false_type; }; template using __ull_constant = integral_constant; template 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 struct _Power_help<_Base, _Dig> { using __valid_digit = typename _Digit<_Base, _Dig>::__valid; using type = __ull_constant<__valid_digit::value>; }; template struct _Power : _Power_help<_Base, _Digs...>::type { }; template struct _Power<_Base> : __ull_constant<0> { }; template 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 struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...> : _Number_help<_Base, _Pow, _Dig, _Digs...> { }; template struct _Number_help<_Base, 1ULL, _Dig> { using type = __ull_constant<_Digit<_Base, _Dig>::value>; }; template struct _Number : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type { }; template struct _Number<_Base> : __ull_constant<0> { }; template struct _Parse_int; template struct _Parse_int<'0', 'b', _Digs...> : _Number<2U, _Digs...>::type { }; template struct _Parse_int<'0', 'B', _Digs...> : _Number<2U, _Digs...>::type { }; template struct _Parse_int<'0', 'x', _Digs...> : _Number<16U, _Digs...>::type { }; template struct _Parse_int<'0', 'X', _Digs...> : _Number<16U, _Digs...>::type { }; template struct _Parse_int<'0', _Digs...> : _Number<8U, _Digs...>::type { }; template struct _Parse_int : _Number<10U, _Digs...>::type { }; } namespace __select_int { template struct _Select_int_base; template struct _Select_int_base<_Val, _IntType, _Ints...> : conditional_t<(_Val <= __gnu_cxx::__int_traits<_IntType>::__max), integral_constant<_IntType, _Val>, _Select_int_base<_Val, _Ints...>> { }; template struct _Select_int_base<_Val> { }; template 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; } } # 44 "/usr/include/c++/10/chrono" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace filesystem { struct __file_clock; }; # 68 "/usr/include/c++/10/chrono" 3 namespace chrono { template> struct duration; template struct time_point; } template struct __duration_common_type { }; template struct __duration_common_type<_CT, _Period1, _Period2, __void_t> { private: using __gcd_num = __static_gcd<_Period1::num, _Period2::num>; using __gcd_den = __static_gcd<_Period1::den, _Period2::den>; using __cr = typename _CT::type; using __r = ratio<__gcd_num::value, (_Period1::den / __gcd_den::value) * _Period2::den>; public: using type = chrono::duration<__cr, typename __r::type>; }; template struct common_type, chrono::duration<_Rep2, _Period2>> : __duration_common_type, typename _Period1::type, typename _Period2::type> { }; template struct common_type, chrono::duration<_Rep, _Period>> { using type = chrono::duration::type, typename _Period::type>; }; template struct common_type> { using type = chrono::duration::type, typename _Period::type>; }; template struct __timepoint_common_type { }; template struct __timepoint_common_type<_CT, _Clock, __void_t> { using type = chrono::time_point<_Clock, typename _CT::type>; }; template struct common_type, chrono::time_point<_Clock, _Duration2>> : __timepoint_common_type, _Clock> { }; template struct common_type, chrono::time_point<_Clock, _Duration>> { using type = chrono::time_point<_Clock, _Duration>; }; template struct common_type> { using type = chrono::time_point<_Clock, _Duration>; }; namespace chrono { template struct __duration_cast_impl { template static constexpr _ToDur __cast(const duration<_Rep, _Period>& __d) { typedef typename _ToDur::rep __to_rep; return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num) / static_cast<_CR>(_CF::den))); } }; template struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> { template static constexpr _ToDur __cast(const duration<_Rep, _Period>& __d) { typedef typename _ToDur::rep __to_rep; return _ToDur(static_cast<__to_rep>(__d.count())); } }; template struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> { template static constexpr _ToDur __cast(const duration<_Rep, _Period>& __d) { typedef typename _ToDur::rep __to_rep; return _ToDur(static_cast<__to_rep>( static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); } }; template struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> { template static constexpr _ToDur __cast(const duration<_Rep, _Period>& __d) { typedef typename _ToDur::rep __to_rep; return _ToDur(static_cast<__to_rep>( static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); } }; template struct __is_duration : std::false_type { }; template struct __is_duration> : std::true_type { }; template using __enable_if_is_duration = typename enable_if<__is_duration<_Tp>::value, _Tp>::type; template using __disable_if_is_duration = typename enable_if::value, _Tp>::type; template constexpr __enable_if_is_duration<_ToDur> duration_cast(const duration<_Rep, _Period>& __d) { typedef typename _ToDur::period __to_period; typedef typename _ToDur::rep __to_rep; typedef ratio_divide<_Period, __to_period> __cf; typedef typename common_type<__to_rep, _Rep, intmax_t>::type __cr; typedef __duration_cast_impl<_ToDur, __cf, __cr, __cf::num == 1, __cf::den == 1> __dc; return __dc::__cast(__d); } template struct treat_as_floating_point : is_floating_point<_Rep> { }; template inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value; template struct is_clock; template inline constexpr bool is_clock_v = is_clock<_Tp>::value; template struct is_clock : false_type { }; template requires requires { typename _Tp::rep; typename _Tp::period; typename _Tp::duration; typename _Tp::time_point::clock; typename _Tp::time_point::duration; { &_Tp::is_steady } -> same_as; { _Tp::now() } -> same_as; requires same_as>; requires same_as; } struct is_clock<_Tp> : true_type { }; # 335 "/usr/include/c++/10/chrono" 3 template constexpr __enable_if_is_duration<_ToDur> floor(const duration<_Rep, _Period>& __d) { auto __to = chrono::duration_cast<_ToDur>(__d); if (__to > __d) return __to - _ToDur{1}; return __to; } template constexpr __enable_if_is_duration<_ToDur> ceil(const duration<_Rep, _Period>& __d) { auto __to = chrono::duration_cast<_ToDur>(__d); if (__to < __d) return __to + _ToDur{1}; return __to; } template constexpr enable_if_t< __and_<__is_duration<_ToDur>, __not_>>::value, _ToDur> round(const duration<_Rep, _Period>& __d) { _ToDur __t0 = chrono::floor<_ToDur>(__d); _ToDur __t1 = __t0 + _ToDur{1}; auto __diff0 = __d - __t0; auto __diff1 = __t1 - __d; if (__diff0 == __diff1) { if (__t0.count() & 1) return __t1; return __t0; } else if (__diff0 < __diff1) return __t0; return __t1; } template constexpr enable_if_t::is_signed, duration<_Rep, _Period>> abs(duration<_Rep, _Period> __d) { if (__d >= __d.zero()) return __d; return -__d; } template struct duration_values { static constexpr _Rep zero() noexcept { return _Rep(0); } static constexpr _Rep max() noexcept { return numeric_limits<_Rep>::max(); } static constexpr _Rep min() noexcept { return numeric_limits<_Rep>::lowest(); } }; template struct __is_ratio : std::false_type { }; template struct __is_ratio> : std::true_type { }; template struct duration { private: template using __is_float = treat_as_floating_point<_Rep2>; static constexpr intmax_t _S_gcd(intmax_t __m, intmax_t __n) noexcept { return (__m == 0) ? __n : (__n == 0) ? __m : _S_gcd(__n, __m % __n); } template using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2), (_R1::den / __gcd2) * (_R2::num / __gcd1)>; template using __is_harmonic = __bool_constant<__divide<_Period2, _Period>::den == 1>; public: using rep = _Rep; using period = typename _Period::type; static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); static_assert(__is_ratio<_Period>::value, "period must be a specialization of ratio"); static_assert(_Period::num > 0, "period must be positive"); constexpr duration() = default; duration(const duration&) = default; template, __or_<__is_float, __not_<__is_float<_Rep2>>>>> constexpr explicit duration(const _Rep2& __rep) : __r(static_cast(__rep)) { } template, __or_<__is_float, __and_<__is_harmonic<_Period2>, __not_<__is_float<_Rep2>>>>>> constexpr duration(const duration<_Rep2, _Period2>& __d) : __r(duration_cast(__d).count()) { } ~duration() = default; duration& operator=(const duration&) = default; constexpr rep count() const { return __r; } constexpr duration::type, period> operator+() const { return duration::type, period>(__r); } constexpr duration::type, period> operator-() const { return duration::type, period>(-__r); } constexpr duration& operator++() { ++__r; return *this; } constexpr duration operator++(int) { return duration(__r++); } constexpr duration& operator--() { --__r; return *this; } constexpr duration operator--(int) { return duration(__r--); } constexpr duration& operator+=(const duration& __d) { __r += __d.count(); return *this; } constexpr duration& operator-=(const duration& __d) { __r -= __d.count(); return *this; } constexpr duration& operator*=(const rep& __rhs) { __r *= __rhs; return *this; } constexpr duration& operator/=(const rep& __rhs) { __r /= __rhs; return *this; } template constexpr typename enable_if::value, duration&>::type operator%=(const rep& __rhs) { __r %= __rhs; return *this; } template constexpr typename enable_if::value, duration&>::type operator%=(const duration& __d) { __r %= __d.count(); return *this; } static constexpr duration zero() noexcept { return duration(duration_values::zero()); } static constexpr duration min() noexcept { return duration(duration_values::min()); } static constexpr duration max() noexcept { return duration(duration_values::max()); } private: rep __r; }; template constexpr typename common_type, duration<_Rep2, _Period2>>::type operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep1, _Period1> __dur1; typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<__dur1,__dur2>::type __cd; return __cd(__cd(__lhs).count() + __cd(__rhs).count()); } template constexpr typename common_type, duration<_Rep2, _Period2>>::type operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep1, _Period1> __dur1; typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<__dur1,__dur2>::type __cd; return __cd(__cd(__lhs).count() - __cd(__rhs).count()); } # 625 "/usr/include/c++/10/chrono" 3 template::type> using __common_rep_t = typename enable_if::value, _CRep>::type; template constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period> operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) { typedef duration::type, _Period> __cd; return __cd(__cd(__d).count() * __s); } template constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period> operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) { return __d * __s; } template constexpr duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) { typedef duration::type, _Period> __cd; return __cd(__cd(__d).count() / __s); } template constexpr typename common_type<_Rep1, _Rep2>::type operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep1, _Period1> __dur1; typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<__dur1,__dur2>::type __cd; return __cd(__lhs).count() / __cd(__rhs).count(); } template constexpr duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) { typedef duration::type, _Period> __cd; return __cd(__cd(__d).count() % __s); } template constexpr typename common_type, duration<_Rep2, _Period2>>::type operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep1, _Period1> __dur1; typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<__dur1,__dur2>::type __cd; return __cd(__cd(__lhs).count() % __cd(__rhs).count()); } template constexpr bool operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep1, _Period1> __dur1; typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<__dur1,__dur2>::type __ct; return __ct(__lhs).count() == __ct(__rhs).count(); } template constexpr bool operator<(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep1, _Period1> __dur1; typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<__dur1,__dur2>::type __ct; return __ct(__lhs).count() < __ct(__rhs).count(); } template requires three_way_comparable> constexpr auto operator<=>(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { using __ct = common_type_t, duration<_Rep2, _Period2>>; return __ct(__lhs).count() <=> __ct(__rhs).count(); } # 743 "/usr/include/c++/10/chrono" 3 template constexpr bool operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { return !(__rhs < __lhs); } template constexpr bool operator>(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { return __rhs < __lhs; } template constexpr bool operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { return !(__lhs < __rhs); } # 777 "/usr/include/c++/10/chrono" 3 using nanoseconds = duration; using microseconds = duration; using milliseconds = duration; using seconds = duration; using minutes = duration>; using hours = duration>; using days = duration>; using weeks = duration>; using years = duration>; using months = duration>; template struct time_point { static_assert(__is_duration<_Dur>::value, "duration must be a specialization of std::chrono::duration"); typedef _Clock clock; typedef _Dur duration; typedef typename duration::rep rep; typedef typename duration::period period; constexpr time_point() : __d(duration::zero()) { } constexpr explicit time_point(const duration& __dur) : __d(__dur) { } template>> constexpr time_point(const time_point& __t) : __d(__t.time_since_epoch()) { } constexpr duration time_since_epoch() const { return __d; } constexpr time_point& operator+=(const duration& __dur) { __d += __dur; return *this; } constexpr time_point& operator-=(const duration& __dur) { __d -= __dur; return *this; } static constexpr time_point min() noexcept { return time_point(duration::min()); } static constexpr time_point max() noexcept { return time_point(duration::max()); } private: duration __d; }; template constexpr typename enable_if<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>::type time_point_cast(const time_point<_Clock, _Dur>& __t) { typedef time_point<_Clock, _ToDur> __time_point; return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); } template constexpr enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> floor(const time_point<_Clock, _Dur>& __tp) { return time_point<_Clock, _ToDur>{ chrono::floor<_ToDur>(__tp.time_since_epoch())}; } template constexpr enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> ceil(const time_point<_Clock, _Dur>& __tp) { return time_point<_Clock, _ToDur>{ chrono::ceil<_ToDur>(__tp.time_since_epoch())}; } template constexpr enable_if_t< __and_<__is_duration<_ToDur>, __not_>>::value, time_point<_Clock, _ToDur>> round(const time_point<_Clock, _Dur>& __tp) { return time_point<_Clock, _ToDur>{ chrono::round<_ToDur>(__tp.time_since_epoch())}; } template constexpr time_point<_Clock, typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> operator+(const time_point<_Clock, _Dur1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<_Dur1,__dur2>::type __ct; typedef time_point<_Clock, __ct> __time_point; return __time_point(__lhs.time_since_epoch() + __rhs); } template constexpr time_point<_Clock, typename common_type, _Dur2>::type> operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { typedef duration<_Rep1, _Period1> __dur1; typedef typename common_type<__dur1,_Dur2>::type __ct; typedef time_point<_Clock, __ct> __time_point; return __time_point(__rhs.time_since_epoch() + __lhs); } template constexpr time_point<_Clock, typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> operator-(const time_point<_Clock, _Dur1>& __lhs, const duration<_Rep2, _Period2>& __rhs) { typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<_Dur1,__dur2>::type __ct; typedef time_point<_Clock, __ct> __time_point; return __time_point(__lhs.time_since_epoch() -__rhs); } template constexpr typename common_type<_Dur1, _Dur2>::type operator-(const time_point<_Clock, _Dur1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } template constexpr bool operator==(const time_point<_Clock, _Dur1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } template _Dur2> constexpr auto operator<=>(const time_point<_Clock, _Dur1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { return __lhs.time_since_epoch() <=> __rhs.time_since_epoch(); } # 986 "/usr/include/c++/10/chrono" 3 template constexpr bool operator<(const time_point<_Clock, _Dur1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } template constexpr bool operator<=(const time_point<_Clock, _Dur1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { return !(__rhs < __lhs); } template constexpr bool operator>(const time_point<_Clock, _Dur1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { return __rhs < __lhs; } template constexpr bool operator>=(const time_point<_Clock, _Dur1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) { return !(__lhs < __rhs); } # 1030 "/usr/include/c++/10/chrono" 3 inline namespace _V2 { struct system_clock { typedef chrono::nanoseconds duration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point time_point; static_assert(system_clock::duration::min() < system_clock::duration::zero(), "a clock's minimum duration cannot be less than its epoch"); static constexpr bool is_steady = false; static time_point now() noexcept; static std::time_t to_time_t(const time_point& __t) noexcept { return std::time_t(duration_cast (__t.time_since_epoch()).count()); } static time_point from_time_t(std::time_t __t) noexcept { typedef chrono::time_point __from; return time_point_cast (__from(chrono::seconds(__t))); } }; # 1078 "/usr/include/c++/10/chrono" 3 struct steady_clock { typedef chrono::nanoseconds duration; typedef duration::rep rep; typedef duration::period period; typedef chrono::time_point time_point; static constexpr bool is_steady = true; static time_point now() noexcept; }; # 1100 "/usr/include/c++/10/chrono" 3 using high_resolution_clock = system_clock; } template using sys_time = time_point; using sys_seconds = sys_time; using sys_days = sys_time; using file_clock = ::std::filesystem::__file_clock; template using file_time = time_point; template<> struct is_clock : true_type { }; template<> struct is_clock : true_type { }; template<> struct is_clock : true_type { }; template<> inline constexpr bool is_clock_v = true; template<> inline constexpr bool is_clock_v = true; template<> inline constexpr bool is_clock_v = true; struct local_t { }; template using local_time = time_point; using local_seconds = local_time; using local_days = local_time; } inline namespace literals { # 1162 "/usr/include/c++/10/chrono" 3 inline namespace chrono_literals { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wliteral-suffix" template constexpr _Dur __check_overflow() { using _Val = __parse_int::_Parse_int<_Digits...>; constexpr typename _Dur::rep __repval = _Val::value; static_assert(__repval >= 0 && __repval == _Val::value, "literal value cannot be represented by duration type"); return _Dur(__repval); } constexpr chrono::duration> operator""h(long double __hours) { return chrono::duration>{__hours}; } template constexpr chrono::hours operator""h() { return __check_overflow(); } constexpr chrono::duration> operator""min(long double __mins) { return chrono::duration>{__mins}; } template constexpr chrono::minutes operator""min() { return __check_overflow(); } constexpr chrono::duration operator""s(long double __secs) { return chrono::duration{__secs}; } template constexpr chrono::seconds operator""s() { return __check_overflow(); } constexpr chrono::duration operator""ms(long double __msecs) { return chrono::duration{__msecs}; } template constexpr chrono::milliseconds operator""ms() { return __check_overflow(); } constexpr chrono::duration operator""us(long double __usecs) { return chrono::duration{__usecs}; } template constexpr chrono::microseconds operator""us() { return __check_overflow(); } constexpr chrono::duration operator""ns(long double __nsecs) { return chrono::duration{__nsecs}; } template constexpr chrono::nanoseconds operator""ns() { return __check_overflow(); } #pragma GCC diagnostic pop } } namespace chrono { using namespace literals::chrono_literals; } namespace filesystem { struct __file_clock { using duration = chrono::nanoseconds; using rep = duration::rep; using period = duration::period; using time_point = chrono::time_point<__file_clock>; static constexpr bool is_steady = false; static time_point now() noexcept { return _S_from_sys(chrono::system_clock::now()); } template static chrono::file_time<_Dur> from_sys(const chrono::sys_time<_Dur>& __t) noexcept { return _S_from_sys(__t); } template static chrono::sys_time<_Dur> to_sys(const chrono::file_time<_Dur>& __t) noexcept { return _S_to_sys(__t); } private: using __sys_clock = chrono::system_clock; static constexpr chrono::seconds _S_epoch_diff{6437664000}; protected: template static chrono::time_point<__file_clock, _Dur> _S_from_sys(const chrono::time_point<__sys_clock, _Dur>& __t) noexcept { using __file_time = chrono::time_point<__file_clock, _Dur>; return __file_time{__t.time_since_epoch()} - _S_epoch_diff; } template static chrono::time_point<__sys_clock, _Dur> _S_to_sys(const chrono::time_point<__file_clock, _Dur>& __t) noexcept { using __sys_time = chrono::time_point<__sys_clock, _Dur>; return __sys_time{__t.time_since_epoch()} + _S_epoch_diff; } }; } } # 14 "all-std.cxx" 2 # 1 "/usr/include/c++/10/csetjmp" 1 3 # 39 "/usr/include/c++/10/csetjmp" 3 # 40 "/usr/include/c++/10/csetjmp" 3 # 1 "/usr/include/setjmp.h" 1 3 4 # 27 "/usr/include/setjmp.h" 3 4 extern "C" { struct __jmp_buf_tag { __jmp_buf __jmpbuf; int __mask_was_saved; __sigset_t __saved_mask; }; typedef struct __jmp_buf_tag jmp_buf[1]; extern int setjmp (jmp_buf __env) throw (); extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) throw (); extern int _setjmp (struct __jmp_buf_tag __env[1]) throw (); # 67 "/usr/include/setjmp.h" 3 4 extern void longjmp (struct __jmp_buf_tag __env[1], int __val) throw () __attribute__ ((__noreturn__)); extern void _longjmp (struct __jmp_buf_tag __env[1], int __val) throw () __attribute__ ((__noreturn__)); typedef struct __jmp_buf_tag sigjmp_buf[1]; # 93 "/usr/include/setjmp.h" 3 4 extern void siglongjmp (sigjmp_buf __env, int __val) throw () __attribute__ ((__noreturn__)); # 103 "/usr/include/setjmp.h" 3 4 } # 43 "/usr/include/c++/10/csetjmp" 2 3 # 55 "/usr/include/c++/10/csetjmp" 3 namespace std { using ::jmp_buf; using ::longjmp; } # 16 "all-std.cxx" 2 # 1 "/usr/include/c++/10/csignal" 1 3 # 39 "/usr/include/c++/10/csignal" 3 # 40 "/usr/include/c++/10/csignal" 3 # 1 "/usr/include/signal.h" 1 3 4 # 27 "/usr/include/signal.h" 3 4 extern "C" { # 1 "/usr/include/x86_64-linux-gnu/bits/signum.h" 1 3 4 # 26 "/usr/include/x86_64-linux-gnu/bits/signum.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/signum-generic.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/signum.h" 2 3 4 # 31 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h" 1 3 4 typedef __sig_atomic_t sig_atomic_t; # 33 "/usr/include/signal.h" 2 3 4 # 57 "/usr/include/signal.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 1 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 5 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h" 3 4 union sigval { int sival_int; void *sival_ptr; }; typedef union sigval __sigval_t; # 7 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4 # 16 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-arch.h" 1 3 4 # 17 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 2 3 4 # 36 "/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h" 3 4 typedef struct { int si_signo; int si_errno; int si_code; int __pad0; union { int _pad[((128 / sizeof (int)) - 4)]; struct { __pid_t si_pid; __uid_t si_uid; } _kill; struct { int si_tid; int si_overrun; __sigval_t si_sigval; } _timer; struct { __pid_t si_pid; __uid_t si_uid; __sigval_t si_sigval; } _rt; struct { __pid_t si_pid; __uid_t si_uid; int si_status; __clock_t si_utime; __clock_t si_stime; } _sigchld; struct { void *si_addr; short int si_addr_lsb; union { struct { void *_lower; void *_upper; } _addr_bnd; __uint32_t _pkey; } _bounds; } _sigfault; struct { long int si_band; int si_fd; } _sigpoll; struct { void *_call_addr; int _syscall; unsigned int _arch; } _sigsys; } _sifields; } siginfo_t ; # 58 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 1 3 4 # 35 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 3 4 enum { SI_ASYNCNL = -60, SI_DETHREAD = -7, SI_TKILL, SI_SIGIO, SI_ASYNCIO, SI_MESGQ, SI_TIMER, SI_QUEUE, SI_USER, SI_KERNEL = 0x80 # 66 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 3 4 }; enum { ILL_ILLOPC = 1, ILL_ILLOPN, ILL_ILLADR, ILL_ILLTRP, ILL_PRVOPC, ILL_PRVREG, ILL_COPROC, ILL_BADSTK, ILL_BADIADDR }; enum { FPE_INTDIV = 1, FPE_INTOVF, FPE_FLTDIV, FPE_FLTOVF, FPE_FLTUND, FPE_FLTRES, FPE_FLTINV, FPE_FLTSUB, FPE_FLTUNK = 14, FPE_CONDTRAP }; enum { SEGV_MAPERR = 1, SEGV_ACCERR, SEGV_BNDERR, SEGV_PKUERR, SEGV_ACCADI, SEGV_ADIDERR, SEGV_ADIPERR }; enum { BUS_ADRALN = 1, BUS_ADRERR, BUS_OBJERR, BUS_MCEERR_AR, BUS_MCEERR_AO }; enum { TRAP_BRKPT = 1, TRAP_TRACE, TRAP_BRANCH, TRAP_HWBKPT, TRAP_UNK }; enum { CLD_EXITED = 1, CLD_KILLED, CLD_DUMPED, CLD_TRAPPED, CLD_STOPPED, CLD_CONTINUED }; enum { POLL_IN = 1, POLL_OUT, POLL_MSG, POLL_ERR, POLL_PRI, POLL_HUP }; # 1 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h" 1 3 4 # 210 "/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h" 2 3 4 # 59 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/sigval_t.h" 1 3 4 # 16 "/usr/include/x86_64-linux-gnu/bits/types/sigval_t.h" 3 4 typedef __sigval_t sigval_t; # 63 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 1 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 5 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 2 3 4 # 22 "/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h" 3 4 typedef struct sigevent { __sigval_t sigev_value; int sigev_signo; int sigev_notify; union { int _pad[((64 / sizeof (int)) - 4)]; __pid_t _tid; struct { void (*_function) (__sigval_t); pthread_attr_t *_attribute; } _sigev_thread; } _sigev_un; } sigevent_t; # 67 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/sigevent-consts.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/sigevent-consts.h" 3 4 enum { SIGEV_SIGNAL = 0, SIGEV_NONE, SIGEV_THREAD, SIGEV_THREAD_ID = 4 }; # 68 "/usr/include/signal.h" 2 3 4 typedef void (*__sighandler_t) (int); extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler) throw (); extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler) throw (); extern __sighandler_t signal (int __sig, __sighandler_t __handler) throw (); # 112 "/usr/include/signal.h" 3 4 extern int kill (__pid_t __pid, int __sig) throw (); extern int killpg (__pid_t __pgrp, int __sig) throw (); extern int raise (int __sig) throw (); extern __sighandler_t ssignal (int __sig, __sighandler_t __handler) throw (); extern int gsignal (int __sig) throw (); extern void psignal (int __sig, const char *__s); extern void psiginfo (const siginfo_t *__pinfo, const char *__s); # 151 "/usr/include/signal.h" 3 4 extern int sigpause (int __sig) __asm__ ("__xpg_sigpause"); # 170 "/usr/include/signal.h" 3 4 extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__)); extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__)); extern int siggetmask (void) throw () __attribute__ ((__deprecated__)); # 185 "/usr/include/signal.h" 3 4 typedef __sighandler_t sighandler_t; typedef __sighandler_t sig_t; extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1))); extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1))); extern int sigismember (const sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1))); extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); extern int sigandset (sigset_t *__set, const sigset_t *__left, const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3))); extern int sigorset (sigset_t *__set, const sigset_t *__left, const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3))); # 1 "/usr/include/x86_64-linux-gnu/bits/sigaction.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/sigaction.h" 3 4 struct sigaction { union { __sighandler_t sa_handler; void (*sa_sigaction) (int, siginfo_t *, void *); } __sigaction_handler; __sigset_t sa_mask; int sa_flags; void (*sa_restorer) (void); }; # 227 "/usr/include/signal.h" 2 3 4 extern int sigprocmask (int __how, const sigset_t *__restrict __set, sigset_t *__restrict __oset) throw (); extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1))); extern int sigaction (int __sig, const struct sigaction *__restrict __act, struct sigaction *__restrict __oact) throw (); extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1))); extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig) __attribute__ ((__nonnull__ (1, 2))); extern int sigwaitinfo (const sigset_t *__restrict __set, siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1))); extern int sigtimedwait (const sigset_t *__restrict __set, siginfo_t *__restrict __info, const struct timespec *__restrict __timeout) __attribute__ ((__nonnull__ (1))); extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val) throw (); # 286 "/usr/include/signal.h" 3 4 extern const char *const _sys_siglist[(64 + 1)]; extern const char *const sys_siglist[(64 + 1)]; # 1 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 1 3 4 # 31 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 3 4 struct _fpx_sw_bytes { __uint32_t magic1; __uint32_t extended_size; __uint64_t xstate_bv; __uint32_t xstate_size; __uint32_t __glibc_reserved1[7]; }; struct _fpreg { unsigned short significand[4]; unsigned short exponent; }; struct _fpxreg { unsigned short significand[4]; unsigned short exponent; unsigned short __glibc_reserved1[3]; }; struct _xmmreg { __uint32_t element[4]; }; # 123 "/usr/include/x86_64-linux-gnu/bits/sigcontext.h" 3 4 struct _fpstate { __uint16_t cwd; __uint16_t swd; __uint16_t ftw; __uint16_t fop; __uint64_t rip; __uint64_t rdp; __uint32_t mxcsr; __uint32_t mxcr_mask; struct _fpxreg _st[8]; struct _xmmreg _xmm[16]; __uint32_t __glibc_reserved1[24]; }; struct sigcontext { __uint64_t r8; __uint64_t r9; __uint64_t r10; __uint64_t r11; __uint64_t r12; __uint64_t r13; __uint64_t r14; __uint64_t r15; __uint64_t rdi; __uint64_t rsi; __uint64_t rbp; __uint64_t rbx; __uint64_t rdx; __uint64_t rax; __uint64_t rcx; __uint64_t rsp; __uint64_t rip; __uint64_t eflags; unsigned short cs; unsigned short gs; unsigned short fs; unsigned short __pad0; __uint64_t err; __uint64_t trapno; __uint64_t oldmask; __uint64_t cr2; __extension__ union { struct _fpstate * fpstate; __uint64_t __fpstate_word; }; __uint64_t __reserved1 [8]; }; struct _xsave_hdr { __uint64_t xstate_bv; __uint64_t __glibc_reserved1[2]; __uint64_t __glibc_reserved2[5]; }; struct _ymmh_state { __uint32_t ymmh_space[64]; }; struct _xstate { struct _fpstate fpstate; struct _xsave_hdr xstate_hdr; struct _ymmh_state ymmh; }; # 292 "/usr/include/signal.h" 2 3 4 extern int sigreturn (struct sigcontext *__scp) throw (); # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 302 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 1 3 4 # 23 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/types/stack_t.h" 2 3 4 typedef struct { void *ss_sp; int ss_flags; size_t ss_size; } stack_t; # 304 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 1 3 4 # 37 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 3 4 __extension__ typedef long long int greg_t; # 46 "/usr/include/x86_64-linux-gnu/sys/ucontext.h" 3 4 typedef greg_t gregset_t[23]; enum { REG_R8 = 0, REG_R9, REG_R10, REG_R11, REG_R12, REG_R13, REG_R14, REG_R15, REG_RDI, REG_RSI, REG_RBP, REG_RBX, REG_RDX, REG_RAX, REG_RCX, REG_RSP, REG_RIP, REG_EFL, REG_CSGSFS, REG_ERR, REG_TRAPNO, REG_OLDMASK, REG_CR2 }; struct _libc_fpxreg { unsigned short int significand[4]; unsigned short int exponent; unsigned short int __glibc_reserved1[3]; }; struct _libc_xmmreg { __uint32_t element[4]; }; struct _libc_fpstate { __uint16_t cwd; __uint16_t swd; __uint16_t ftw; __uint16_t fop; __uint64_t rip; __uint64_t rdp; __uint32_t mxcsr; __uint32_t mxcr_mask; struct _libc_fpxreg _st[8]; struct _libc_xmmreg _xmm[16]; __uint32_t __glibc_reserved1[24]; }; typedef struct _libc_fpstate *fpregset_t; typedef struct { gregset_t gregs; fpregset_t fpregs; __extension__ unsigned long long __reserved1 [8]; } mcontext_t; typedef struct ucontext_t { unsigned long int uc_flags; struct ucontext_t *uc_link; stack_t uc_stack; mcontext_t uc_mcontext; sigset_t uc_sigmask; struct _libc_fpstate __fpregs_mem; __extension__ unsigned long long int __ssp[4]; } ucontext_t; # 307 "/usr/include/signal.h" 2 3 4 extern int siginterrupt (int __sig, int __interrupt) throw (); # 1 "/usr/include/x86_64-linux-gnu/bits/sigstack.h" 1 3 4 # 317 "/usr/include/signal.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/ss_flags.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/ss_flags.h" 3 4 enum { SS_ONSTACK = 1, SS_DISABLE }; # 318 "/usr/include/signal.h" 2 3 4 extern int sigaltstack (const stack_t *__restrict __ss, stack_t *__restrict __oss) throw (); # 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h" 1 3 4 # 23 "/usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h" 3 4 struct sigstack { void *ss_sp; int ss_onstack; }; # 328 "/usr/include/signal.h" 2 3 4 extern int sigstack (struct sigstack *__ss, struct sigstack *__oss) throw () __attribute__ ((__deprecated__)); extern int sighold (int __sig) throw (); extern int sigrelse (int __sig) throw (); extern int sigignore (int __sig) throw (); extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw (); # 1 "/usr/include/x86_64-linux-gnu/bits/sigthread.h" 1 3 4 # 31 "/usr/include/x86_64-linux-gnu/bits/sigthread.h" 3 4 extern int pthread_sigmask (int __how, const __sigset_t *__restrict __newmask, __sigset_t *__restrict __oldmask)throw (); extern int pthread_kill (pthread_t __threadid, int __signo) throw (); extern int pthread_sigqueue (pthread_t __threadid, int __signo, const union sigval __value) throw (); # 360 "/usr/include/signal.h" 2 3 4 extern int __libc_current_sigrtmin (void) throw (); extern int __libc_current_sigrtmax (void) throw (); # 1 "/usr/include/x86_64-linux-gnu/bits/signal_ext.h" 1 3 4 # 29 "/usr/include/x86_64-linux-gnu/bits/signal_ext.h" 3 4 extern int tgkill (__pid_t __tgid, __pid_t __tid, int __signal); # 375 "/usr/include/signal.h" 2 3 4 } # 43 "/usr/include/c++/10/csignal" 2 3 namespace std { using ::sig_atomic_t; using ::signal; using ::raise; } # 17 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cstdarg" 1 3 # 39 "/usr/include/c++/10/cstdarg" 3 # 40 "/usr/include/c++/10/cstdarg" 3 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdarg.h" 1 3 4 # 44 "/usr/include/c++/10/cstdarg" 2 3 # 53 "/usr/include/c++/10/cstdarg" 3 namespace std { using ::va_list; } # 18 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cstddef" 1 3 # 42 "/usr/include/c++/10/cstddef" 3 # 43 "/usr/include/c++/10/cstddef" 3 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 51 "/usr/include/c++/10/cstddef" 2 3 extern "C++" { namespace std { using ::max_align_t; } namespace std { enum class byte : unsigned char {}; template struct __byte_operand { }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; template<> struct __byte_operand { using __type = byte; }; # 110 "/usr/include/c++/10/cstddef" 3 template struct __byte_operand : __byte_operand<_IntegerType> { }; template struct __byte_operand : __byte_operand<_IntegerType> { }; template struct __byte_operand : __byte_operand<_IntegerType> { }; template using __byte_op_t = typename __byte_operand<_IntegerType>::__type; template constexpr __byte_op_t<_IntegerType> operator<<(byte __b, _IntegerType __shift) noexcept { return (byte)(unsigned char)((unsigned)__b << __shift); } template constexpr __byte_op_t<_IntegerType> operator>>(byte __b, _IntegerType __shift) noexcept { return (byte)(unsigned char)((unsigned)__b >> __shift); } constexpr byte operator|(byte __l, byte __r) noexcept { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } constexpr byte operator&(byte __l, byte __r) noexcept { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } constexpr byte operator^(byte __l, byte __r) noexcept { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } constexpr byte operator~(byte __b) noexcept { return (byte)(unsigned char)~(unsigned)__b; } template constexpr __byte_op_t<_IntegerType>& operator<<=(byte& __b, _IntegerType __shift) noexcept { return __b = __b << __shift; } template constexpr __byte_op_t<_IntegerType>& operator>>=(byte& __b, _IntegerType __shift) noexcept { return __b = __b >> __shift; } constexpr byte& operator|=(byte& __l, byte __r) noexcept { return __l = __l | __r; } constexpr byte& operator&=(byte& __l, byte __r) noexcept { return __l = __l & __r; } constexpr byte& operator^=(byte& __l, byte __r) noexcept { return __l = __l ^ __r; } template constexpr _IntegerType to_integer(__byte_op_t<_IntegerType> __b) noexcept { return _IntegerType(__b); } } } # 19 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cstdlib" 1 3 # 39 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/cstdlib" 3 # 20 "all-std.cxx" 2 # 1 "/usr/include/c++/10/ctime" 1 3 # 39 "/usr/include/c++/10/ctime" 3 # 40 "/usr/include/c++/10/ctime" 3 # 21 "all-std.cxx" 2 # 1 "/usr/include/c++/10/functional" 1 3 # 46 "/usr/include/c++/10/functional" 3 # 47 "/usr/include/c++/10/functional" 3 # 1 "/usr/include/c++/10/tuple" 1 3 # 32 "/usr/include/c++/10/tuple" 3 # 33 "/usr/include/c++/10/tuple" 3 # 1 "/usr/include/c++/10/array" 1 3 # 32 "/usr/include/c++/10/array" 3 # 33 "/usr/include/c++/10/array" 3 # 43 "/usr/include/c++/10/array" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct __array_traits { typedef _Tp _Type[_Nm]; typedef __is_swappable<_Tp> _Is_swappable; typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable; static constexpr _Tp& _S_ref(const _Type& __t, std::size_t __n) noexcept { return const_cast<_Tp&>(__t[__n]); } static constexpr _Tp* _S_ptr(const _Type& __t) noexcept { return const_cast<_Tp*>(__t); } }; template struct __array_traits<_Tp, 0> { struct _Type { }; typedef true_type _Is_swappable; typedef true_type _Is_nothrow_swappable; static constexpr _Tp& _S_ref(const _Type&, std::size_t) noexcept { return *static_cast<_Tp*>(nullptr); } static constexpr _Tp* _S_ptr(const _Type&) noexcept { return nullptr; } }; # 93 "/usr/include/c++/10/array" 3 template 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 reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::__array_traits<_Tp, _Nm> _AT_Type; typename _AT_Type::_Type _M_elems; constexpr void fill(const value_type& __u) { std::fill_n(begin(), size(), __u); } constexpr void swap(array& __other) noexcept(_AT_Type::_Is_nothrow_swappable::value) { std::swap_ranges(begin(), end(), __other.begin()); } constexpr iterator begin() noexcept { return iterator(data()); } constexpr const_iterator begin() const noexcept { return const_iterator(data()); } constexpr iterator end() noexcept { return iterator(data() + _Nm); } constexpr const_iterator end() const noexcept { return const_iterator(data() + _Nm); } constexpr reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } constexpr reverse_iterator rend() noexcept { return reverse_iterator(begin()); } constexpr const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } constexpr const_iterator cbegin() const noexcept { return const_iterator(data()); } constexpr const_iterator cend() const noexcept { return const_iterator(data() + _Nm); } constexpr const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } constexpr const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } constexpr size_type size() const noexcept { return _Nm; } constexpr size_type max_size() const noexcept { return _Nm; } [[__nodiscard__]] constexpr bool empty() const noexcept { return size() == 0; } constexpr reference operator[](size_type __n) noexcept { return _AT_Type::_S_ref(_M_elems, __n); } constexpr const_reference operator[](size_type __n) const noexcept { return _AT_Type::_S_ref(_M_elems, __n); } constexpr reference at(size_type __n) { if (__n >= _Nm) std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)") , __n, _Nm); return _AT_Type::_S_ref(_M_elems, __n); } constexpr const_reference at(size_type __n) const { return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)") , __n, _Nm), _AT_Type::_S_ref(_M_elems, 0)); } constexpr reference front() noexcept { return *begin(); } constexpr const_reference front() const noexcept { return _AT_Type::_S_ref(_M_elems, 0); } constexpr reference back() noexcept { return _Nm ? *(end() - 1) : *end(); } constexpr const_reference back() const noexcept { return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) : _AT_Type::_S_ref(_M_elems, 0); } constexpr pointer data() noexcept { return _AT_Type::_S_ptr(_M_elems); } constexpr const_pointer data() const noexcept { return _AT_Type::_S_ptr(_M_elems); } }; template array(_Tp, _Up...) -> array && ...), _Tp>, 1 + sizeof...(_Up)>; template constexpr inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::equal(__one.begin(), __one.end(), __two.begin()); } template 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; } # 314 "/usr/include/c++/10/array" 3 template constexpr inline typename enable_if< std::__array_traits<_Tp, _Nm>::_Is_swappable::value >::type swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) noexcept(noexcept(__one.swap(__two))) { __one.swap(__two); } template typename enable_if< !std::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; template constexpr _Tp& get(array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return std::__array_traits<_Tp, _Nm>:: _S_ref(__arr._M_elems, _Int); } template 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 constexpr const _Tp& get(const array<_Tp, _Nm>& __arr) noexcept { static_assert(_Int < _Nm, "array index is within bounds"); return std::__array_traits<_Tp, _Nm>:: _S_ref(__arr._M_elems, _Int); } template 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 constexpr array, sizeof...(_Idx)> __to_array(_Tp (&__a)[sizeof...(_Idx)], index_sequence<_Idx...>) { if constexpr (_Move) return {{std::move(__a[_Idx])...}}; else return {{__a[_Idx]...}}; } template constexpr array, _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&>) return std::__to_array(__a, make_index_sequence<_Nm>{}); __builtin_unreachable(); } template constexpr array, _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>) return std::__to_array<1>(__a, make_index_sequence<_Nm>{}); __builtin_unreachable(); } } namespace std __attribute__ ((__visibility__ ("default"))) { template struct tuple_size; template struct tuple_size> : public integral_constant { }; template struct tuple_element; template struct tuple_element<_Int, std::array<_Tp, _Nm>> { static_assert(_Int < _Nm, "index is out of bounds"); typedef _Tp type; }; template struct __is_tuple_like_impl> : true_type { }; } # 40 "/usr/include/c++/10/tuple" 2 3 # 1 "/usr/include/c++/10/bits/uses_allocator.h" 1 3 # 35 "/usr/include/c++/10/bits/uses_allocator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct __erased_type { }; template using __is_erased_or_convertible = __or_, 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> struct __uses_allocator_helper : false_type { }; template struct __uses_allocator_helper<_Tp, _Alloc, __void_t> : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type { }; template 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 struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; template struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; template struct __uses_alloc; template struct __uses_alloc : conditional< is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, __uses_alloc1<_Alloc>, __uses_alloc2<_Alloc>>::type { static_assert(__or_< is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, is_constructible<_Tp, _Args..., const _Alloc&>>::value, "construction with an allocator must be possible" " if uses_allocator is true"); }; template struct __uses_alloc : __uses_alloc0 { }; template using __uses_alloc_t = __uses_alloc::value, _Tp, _Alloc, _Args...>; template 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 void __use_alloc(const _Alloc&&) = delete; template inline constexpr bool uses_allocator_v = uses_allocator<_Tp, _Alloc>::value; template class _Predicate, typename _Tp, typename _Alloc, typename... _Args> struct __is_uses_allocator_predicate : conditional::value, __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, _Predicate<_Tp, _Args..., _Alloc>>, _Predicate<_Tp, _Args...>>::type { }; template struct __is_uses_allocator_constructible : __is_uses_allocator_predicate { }; template inline constexpr bool __is_uses_allocator_constructible_v = __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; template struct __is_nothrow_uses_allocator_constructible : __is_uses_allocator_predicate { }; template inline constexpr bool __is_nothrow_uses_allocator_constructible_v = __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; template void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, _Args&&... __args) { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } template 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 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 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 "/usr/include/c++/10/tuple" 2 3 # 1 "/usr/include/c++/10/bits/invoke.h" 1 3 # 33 "/usr/include/c++/10/bits/invoke.h" 3 # 34 "/usr/include/c++/10/bits/invoke.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 52 "/usr/include/c++/10/bits/invoke.h" 3 template::type> constexpr _Up&& __invfwd(typename remove_reference<_Tp>::type& __t) noexcept { return static_cast<_Up&&>(__t); } template constexpr _Res __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } template constexpr _Res __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, _Args&&... __args) { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } template constexpr _Res __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, _Args&&... __args) { return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); } template constexpr _Res __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) { return __invfwd<_Tp>(__t).*__f; } template constexpr _Res __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) { return (*std::forward<_Tp>(__t)).*__f; } template 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 constexpr enable_if_t, _Res> __invoke_r(_Callable&& __fn, _Args&&... __args) noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) { using __result = __invoke_result<_Callable, _Args...>; using __type = typename __result::type; using __tag = typename __result::__invoke_type; if constexpr (is_void_v<_Res>) std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); else return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); } # 158 "/usr/include/c++/10/bits/invoke.h" 3 } # 42 "/usr/include/c++/10/tuple" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class tuple; template struct __is_empty_non_tuple : is_empty<_Tp> { }; template struct __is_empty_non_tuple> : false_type { }; template using __empty_not_final = typename conditional<__is_final(_Tp), false_type, __is_empty_non_tuple<_Tp>>::type; template::value> struct _Head_base; template struct _Head_base<_Idx, _Head, true> : public _Head { constexpr _Head_base() : _Head() { } constexpr _Head_base(const _Head& __h) : _Head(__h) { } constexpr _Head_base(const _Head_base&) = default; constexpr _Head_base(_Head_base&&) = default; template constexpr _Head_base(_UHead&& __h) : _Head(std::forward<_UHead>(__h)) { } _Head_base(allocator_arg_t, __uses_alloc0) : _Head() { } template _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) : _Head(allocator_arg, *__a._M_a) { } template _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) : _Head(*__a._M_a) { } template _Head_base(__uses_alloc0, _UHead&& __uhead) : _Head(std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { } static constexpr _Head& _M_head(_Head_base& __b) noexcept { return __b; } static constexpr const _Head& _M_head(const _Head_base& __b) noexcept { return __b; } }; template 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 constexpr _Head_base(_UHead&& __h) : _M_head_impl(std::forward<_UHead>(__h)) { } constexpr _Head_base(allocator_arg_t, __uses_alloc0) : _M_head_impl() { } template _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) : _M_head_impl(allocator_arg, *__a._M_a) { } template _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) : _M_head_impl(*__a._M_a) { } template constexpr _Head_base(__uses_alloc0, _UHead&& __uhead) : _M_head_impl(std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { } template _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } static constexpr _Head& _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } static constexpr const _Head& _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } _Head _M_head_impl; }; # 182 "/usr/include/c++/10/tuple" 3 template struct _Tuple_impl; template struct _Tuple_impl<_Idx, _Head, _Tail...> : public _Tuple_impl<_Idx + 1, _Tail...>, private _Head_base<_Idx, _Head> { template friend class _Tuple_impl; typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; typedef _Head_base<_Idx, _Head> _Base; static constexpr _Head& _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } static constexpr const _Head& _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } static constexpr _Inherited& _M_tail(_Tuple_impl& __t) noexcept { return __t; } static constexpr const _Inherited& _M_tail(const _Tuple_impl& __t) noexcept { return __t; } constexpr _Tuple_impl() : _Inherited(), _Base() { } explicit constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) : _Inherited(__tail...), _Base(__head) { } template::type> explicit constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) : _Inherited(std::forward<_UTail>(__tail)...), _Base(std::forward<_UHead>(__head)) { } constexpr _Tuple_impl(const _Tuple_impl&) = default; _Tuple_impl& operator=(const _Tuple_impl&) = delete; constexpr _Tuple_impl(_Tuple_impl&& __in) noexcept(__and_, is_nothrow_move_constructible<_Inherited>>::value) : _Inherited(std::move(_M_tail(__in))), _Base(std::forward<_Head>(_M_head(__in))) { } template 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 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 constexpr _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a), _Base(__tag, __use_alloc<_Head>(__a)) { } template _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::type> 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 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 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 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 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 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 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))); } protected: constexpr void _M_swap(_Tuple_impl& __in) { using std::swap; swap(_M_head(*this), _M_head(__in)); _Inherited::_M_swap(_M_tail(__in)); } }; template struct _Tuple_impl<_Idx, _Head> : private _Head_base<_Idx, _Head> { template friend class _Tuple_impl; typedef _Head_base<_Idx, _Head> _Base; static constexpr _Head& _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } static constexpr const _Head& _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } constexpr _Tuple_impl() : _Base() { } explicit constexpr _Tuple_impl(const _Head& __head) : _Base(__head) { } template explicit constexpr _Tuple_impl(_UHead&& __head) : _Base(std::forward<_UHead>(__head)) { } constexpr _Tuple_impl(const _Tuple_impl&) = default; _Tuple_impl& operator=(const _Tuple_impl&) = delete; constexpr _Tuple_impl(_Tuple_impl&& __in) noexcept(is_nothrow_move_constructible<_Head>::value) : _Base(std::forward<_Head>(_M_head(__in))) { } template constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { } template constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) { } template constexpr _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) : _Base(__tag, __use_alloc<_Head>(__a)) { } template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Head& __head) : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { } template constexpr _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _UHead&& __head) : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), std::forward<_UHead>(__head)) { } template constexpr _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl& __in) : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } template constexpr _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl&& __in) : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), std::forward<_Head>(_M_head(__in))) { } template constexpr _Tuple_impl(allocator_arg_t __tag, 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 constexpr _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl<_Idx, _UHead>&& __in) : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) { } template constexpr void _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) { _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); } template constexpr void _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) { _M_head(*this) = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); } protected: constexpr void _M_swap(_Tuple_impl& __in) { using std::swap; swap(_M_head(*this), _M_head(__in)); } }; template struct _TupleConstraints { template using is_constructible = __bool_constant<__is_constructible(_Tp, _Up)>; template static constexpr bool __is_implicitly_constructible() { return __and_..., is_convertible<_UTypes, _Types>... >::value; } template static constexpr bool __is_explicitly_constructible() { return __and_..., __not_<__and_...>> >::value; } static constexpr bool __is_implicitly_default_constructible() { return __and_... >::value; } static constexpr bool __is_explicitly_default_constructible() { return __and_..., __not_<__and_< std::__is_implicitly_default_constructible<_Types>...> >>::value; } }; template struct _TupleConstraints { template static constexpr bool __is_implicitly_constructible() { return false; } template static constexpr bool __is_explicitly_constructible() { return false; } }; template class tuple : public _Tuple_impl<0, _Elements...> { typedef _Tuple_impl<0, _Elements...> _Inherited; template using _TCC = _TupleConstraints<_Cond, _Elements...>; template using _ImplicitDefaultCtor = __enable_if_t< _TCC<_Dummy>::__is_implicitly_default_constructible(), bool>; template using _ExplicitDefaultCtor = __enable_if_t< _TCC<_Dummy>::__is_explicitly_default_constructible(), bool>; template using _ImplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), bool>; template using _ExplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), bool>; template static constexpr __enable_if_t __assignable() { return __and_...>::value; } template static constexpr bool __nothrow_assignable() { return __and_...>::value; } template static constexpr bool __nothrow_constructible() { return __and_...>::value; } template static constexpr bool __valid_args() { return sizeof...(_Elements) == 1 && !is_same>::value; } template static constexpr bool __valid_args() { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } # 595 "/usr/include/c++/10/tuple" 3 template> struct _UseOtherCtor : false_type { }; template struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> : __or_, is_constructible<_Tp, _Tuple>> { }; template struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> : true_type { }; template static constexpr bool __use_other_ctor() { return _UseOtherCtor<_Tuple>::value; } public: template::value> = true> constexpr tuple() noexcept(__and_...>::value) : _Inherited() { } template::value> = false> explicit constexpr tuple() noexcept(__and_...>::value) : _Inherited() { } template= 1), _ImplicitCtor<_NotEmpty, const _Elements&...> = true> constexpr tuple(const _Elements&... __elements) noexcept(__nothrow_constructible()) : _Inherited(__elements...) { } template= 1), _ExplicitCtor<_NotEmpty, const _Elements&...> = false> explicit constexpr tuple(const _Elements&... __elements) noexcept(__nothrow_constructible()) : _Inherited(__elements...) { } template(), _ImplicitCtor<_Valid, _UElements...> = true> constexpr tuple(_UElements&&... __elements) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(std::forward<_UElements>(__elements)...) { } template(), _ExplicitCtor<_Valid, _UElements...> = false> explicit constexpr tuple(_UElements&&... __elements) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(std::forward<_UElements>(__elements)...) { } constexpr tuple(const tuple&) = default; constexpr tuple(tuple&&) = default; template&>(), _ImplicitCtor<_Valid, const _UElements&...> = true> constexpr tuple(const tuple<_UElements...>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { } template&>(), _ExplicitCtor<_Valid, const _UElements&...> = false> explicit constexpr tuple(const tuple<_UElements...>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { } template&&>(), _ImplicitCtor<_Valid, _UElements...> = true> constexpr tuple(tuple<_UElements...>&& __in) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } template&&>(), _ExplicitCtor<_Valid, _UElements...> = false> explicit constexpr tuple(tuple<_UElements...>&& __in) noexcept(__nothrow_constructible<_UElements...>()) : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } template::value> = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template= 1), _ImplicitCtor<_NotEmpty, const _Elements&...> = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const _Elements&... __elements) : _Inherited(__tag, __a, __elements...) { } template= 1), _ExplicitCtor<_NotEmpty, const _Elements&...> = false> constexpr explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const _Elements&... __elements) : _Inherited(__tag, __a, __elements...) { } template(), _ImplicitCtor<_Valid, _UElements...> = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, _UElements&&... __elements) : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) { } template(), _ExplicitCtor<_Valid, _UElements...> = false> constexpr explicit tuple(allocator_arg_t __tag, const _Alloc& __a, _UElements&&... __elements) : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) { } template constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) : _Inherited(__tag, __a, static_cast(__in)) { } template constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } template&>(), _ImplicitCtor<_Valid, const _UElements&...> = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_UElements...>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { } template&>(), _ExplicitCtor<_Valid, const _UElements&...> = false> constexpr explicit tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_UElements...>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { } template&&>(), _ImplicitCtor<_Valid, _UElements...> = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UElements...>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } template&&>(), _ExplicitCtor<_Valid, _UElements...> = false> constexpr explicit tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UElements...>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } constexpr tuple& operator=(typename conditional<__assignable(), const tuple&, const __nonesuch&>::type __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } constexpr tuple& operator=(typename conditional<__assignable<_Elements...>(), tuple&&, __nonesuch&&>::type __in) noexcept(__nothrow_assignable<_Elements...>()) { this->_M_assign(std::move(__in)); return *this; } template constexpr __enable_if_t<__assignable(), tuple&> operator=(const tuple<_UElements...>& __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } template constexpr __enable_if_t<__assignable<_UElements...>(), tuple&> operator=(tuple<_UElements...>&& __in) noexcept(__nothrow_assignable<_UElements...>()) { this->_M_assign(std::move(__in)); return *this; } constexpr void swap(tuple& __in) noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) { _Inherited::_M_swap(__in); } }; template tuple(_UTypes...) -> tuple<_UTypes...>; template tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; template tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; template tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; template tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; template<> class tuple<> { public: void swap(tuple&) noexcept { } tuple() = default; template constexpr tuple(allocator_arg_t, const _Alloc&) noexcept { } template constexpr tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } }; template class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> { typedef _Tuple_impl<0, _T1, _T2> _Inherited; template using _ImplicitDefaultCtor = __enable_if_t< _TupleConstraints<_Dummy, _U1, _U2>:: __is_implicitly_default_constructible(), bool>; template using _ExplicitDefaultCtor = __enable_if_t< _TupleConstraints<_Dummy, _U1, _U2>:: __is_explicitly_default_constructible(), bool>; template using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; template using _ImplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), bool>; template using _ExplicitCtor = __enable_if_t< _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), bool>; template static constexpr bool __assignable() { return __and_, is_assignable<_T2&, _U2>>::value; } template static constexpr bool __nothrow_assignable() { return __and_, is_nothrow_assignable<_T2&, _U2>>::value; } template static constexpr bool __nothrow_constructible() { return __and_, is_nothrow_constructible<_T2, _U2>>::value; } static constexpr bool __nothrow_default_constructible() { return __and_, is_nothrow_default_constructible<_T2>>::value; } template static constexpr bool __is_alloc_arg() { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } public: template = true> constexpr tuple() noexcept(__nothrow_default_constructible()) : _Inherited() { } template = false> explicit constexpr tuple() noexcept(__nothrow_default_constructible()) : _Inherited() { } template = true> constexpr tuple(const _T1& __a1, const _T2& __a2) noexcept(__nothrow_constructible()) : _Inherited(__a1, __a2) { } template = false> explicit constexpr tuple(const _T1& __a1, const _T2& __a2) noexcept(__nothrow_constructible()) : _Inherited(__a1, __a2) { } template(), _U1, _U2> = true> constexpr tuple(_U1&& __a1, _U2&& __a2) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } template(), _U1, _U2> = false> explicit constexpr tuple(_U1&& __a1, _U2&& __a2) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } constexpr tuple(const tuple&) = default; constexpr tuple(tuple&&) = default; template = true> constexpr tuple(const tuple<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { } template = false> explicit constexpr tuple(const tuple<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(static_cast&>(__in)) { } template = true> constexpr tuple(tuple<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } template = false> explicit constexpr tuple(tuple<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } template = true> constexpr tuple(const pair<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(__in.first, __in.second) { } template = false> explicit constexpr tuple(const pair<_U1, _U2>& __in) noexcept(__nothrow_constructible()) : _Inherited(__in.first, __in.second) { } template = true> constexpr tuple(pair<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { } template = false> explicit constexpr tuple(pair<_U1, _U2>&& __in) noexcept(__nothrow_constructible<_U1, _U2>()) : _Inherited(std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { } template::value, _T1, _T2> = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a) : _Inherited(__tag, __a) { } template = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const _T1& __a1, const _T2& __a2) : _Inherited(__tag, __a, __a1, __a2) { } template = false> explicit constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const _T1& __a1, const _T2& __a2) : _Inherited(__tag, __a, __a1, __a2) { } template = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) : _Inherited(__tag, __a, std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } template = false> explicit constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) : _Inherited(__tag, __a, std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } template constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) : _Inherited(__tag, __a, static_cast(__in)) { } template constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } template = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_U1, _U2>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { } template = false> explicit constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple<_U1, _U2>& __in) : _Inherited(__tag, __a, static_cast&>(__in)) { } template = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } template = false> explicit constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } template = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const pair<_U1, _U2>& __in) : _Inherited(__tag, __a, __in.first, __in.second) { } template = false> explicit constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, const pair<_U1, _U2>& __in) : _Inherited(__tag, __a, __in.first, __in.second) { } template = true> constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) : _Inherited(__tag, __a, std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { } template = false> explicit constexpr tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) : _Inherited(__tag, __a, std::forward<_U1>(__in.first), std::forward<_U2>(__in.second)) { } constexpr tuple& operator=(typename conditional<__assignable(), const tuple&, const __nonesuch&>::type __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } constexpr tuple& operator=(typename conditional<__assignable<_T1, _T2>(), tuple&&, __nonesuch&&>::type __in) noexcept(__nothrow_assignable<_T1, _T2>()) { this->_M_assign(std::move(__in)); return *this; } template constexpr __enable_if_t<__assignable(), tuple&> operator=(const tuple<_U1, _U2>& __in) noexcept(__nothrow_assignable()) { this->_M_assign(__in); return *this; } template constexpr __enable_if_t<__assignable<_U1, _U2>(), tuple&> operator=(tuple<_U1, _U2>&& __in) noexcept(__nothrow_assignable<_U1, _U2>()) { this->_M_assign(std::move(__in)); return *this; } template constexpr __enable_if_t<__assignable(), tuple&> operator=(const pair<_U1, _U2>& __in) noexcept(__nothrow_assignable()) { this->_M_head(*this) = __in.first; this->_M_tail(*this)._M_head(*this) = __in.second; return *this; } template constexpr __enable_if_t<__assignable<_U1, _U2>(), tuple&> operator=(pair<_U1, _U2>&& __in) noexcept(__nothrow_assignable<_U1, _U2>()) { this->_M_head(*this) = std::forward<_U1>(__in.first); this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); return *this; } constexpr void swap(tuple& __in) noexcept(__and_<__is_nothrow_swappable<_T1>, __is_nothrow_swappable<_T2>>::value) { _Inherited::_M_swap(__in); } }; template struct tuple_size> : public integral_constant { }; template inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; template struct tuple_element<__i, tuple<_Head, _Tail...> > : tuple_element<__i - 1, tuple<_Tail...> > { }; template struct tuple_element<0, tuple<_Head, _Tail...> > { typedef _Head type; }; template struct tuple_element<__i, tuple<>> { static_assert(__i < tuple_size>::value, "tuple index is in range"); }; template constexpr _Head& __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } template constexpr const _Head& __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } template constexpr __tuple_element_t<__i, tuple<_Elements...>>& get(tuple<_Elements...>& __t) noexcept { return std::__get_helper<__i>(__t); } template constexpr const __tuple_element_t<__i, tuple<_Elements...>>& get(const tuple<_Elements...>& __t) noexcept { return std::__get_helper<__i>(__t); } template constexpr __tuple_element_t<__i, tuple<_Elements...>>&& get(tuple<_Elements...>&& __t) noexcept { typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; return std::forward<__element_type&&>(std::get<__i>(__t)); } template 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(std::get<__i>(__t)); } template constexpr _Head& __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } template constexpr const _Head& __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } template constexpr _Tp& get(tuple<_Types...>& __t) noexcept { return std::__get_helper2<_Tp>(__t); } template constexpr _Tp&& get(tuple<_Types...>&& __t) noexcept { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); } template constexpr const _Tp& get(const tuple<_Types...>& __t) noexcept { return std::__get_helper2<_Tp>(__t); } template constexpr const _Tp&& get(const tuple<_Types...>&& __t) noexcept { return std::forward(std::__get_helper2<_Tp>(__t)); } template 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 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 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<_UElements...>, 0, sizeof...(_TElements)>; return __compare::__eq(__t, __u); } template constexpr _Cat __tuple_cmp(const _Tp&, const _Up&, index_sequence<>) { return _Cat::equivalent; } template 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 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...>()); } # 1476 "/usr/include/c++/10/tuple" 3 template constexpr tuple::__type...> make_tuple(_Elements&&... __args) { typedef tuple::__type...> __result_type; return __result_type(std::forward<_Elements>(__args)...); } template constexpr tuple<_Elements&&...> forward_as_tuple(_Elements&&... __args) noexcept { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } template struct __make_tuple_impl; template struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> : __make_tuple_impl<_Idx + 1, tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, _Tuple, _Nm> { }; template struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> { typedef tuple<_Tp...> __type; }; template struct __do_make_tuple : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value> { }; template struct __make_tuple : public __do_make_tuple<__remove_cvref_t<_Tuple>> { }; template struct __combine_tuples; template<> struct __combine_tuples<> { typedef tuple<> __type; }; template struct __combine_tuples> { typedef tuple<_Ts...> __type; }; template struct __combine_tuples, tuple<_T2s...>, _Rem...> { typedef typename __combine_tuples, _Rem...>::__type __type; }; template struct __tuple_cat_result { typedef typename __combine_tuples ::__type...>::__type __type; }; template struct __make_1st_indices; template<> struct __make_1st_indices<> { typedef std::_Index_tuple<> __type; }; template struct __make_1st_indices<_Tp, _Tpls...> { typedef typename std::_Build_index_tuple::type>::value>::__type __type; }; template struct __tuple_concater; template struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...> { template 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 struct __tuple_concater<_Ret, std::_Index_tuple<>> { template static constexpr _Ret _S_do(_Us&&... __us) { return _Ret(std::forward<_Us>(__us)...); } }; template...>::value>::type> constexpr auto tuple_cat(_Tpls&&... __tpls) -> typename __tuple_cat_result<_Tpls...>::__type { typedef typename __tuple_cat_result<_Tpls...>::__type __ret; typedef typename __make_1st_indices<_Tpls...>::__type __idx; typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; return __concater::_S_do(std::forward<_Tpls>(__tpls)...); } template constexpr tuple<_Elements&...> tie(_Elements&... __args) noexcept { return tuple<_Elements&...>(__args...); } template 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 constexpr typename enable_if...>::value>::type swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; struct _Swallow_assign { template constexpr const _Swallow_assign& operator=(const _Tp&) const { return *this; } }; inline constexpr _Swallow_assign ignore{}; template struct uses_allocator, _Alloc> : true_type { }; # 1673 "/usr/include/c++/10/tuple" 3 template template constexpr inline pair<_T1, _T2>:: pair(piecewise_construct_t, tuple<_Args1...> __first, tuple<_Args2...> __second) : pair(__first, __second, typename _Build_index_tuple::__type(), typename _Build_index_tuple::__type()) { } template template 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 class _Trait, typename _Tp, typename _Tuple> inline constexpr bool __unpack_std_tuple = false; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> = _Trait<_Tp, _Up...>::value; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> = _Trait<_Tp, _Up&...>::value; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> = _Trait<_Tp, const _Up...>::value; template class _Trait, typename _Tp, typename... _Up> inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> = _Trait<_Tp, const _Up&...>::value; template 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 constexpr decltype(auto) apply(_Fn&& __f, _Tuple&& __t) noexcept(__unpack_std_tuple) { using _Indices = make_index_sequence>>; return std::__apply_impl(std::forward<_Fn>(__f), std::forward<_Tuple>(__t), _Indices{}); } template constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } template constexpr _Tp make_from_tuple(_Tuple&& __t) noexcept(__unpack_std_tuple) { return __make_from_tuple_impl<_Tp>( std::forward<_Tuple>(__t), make_index_sequence>>{}); } } # 55 "/usr/include/c++/10/functional" 2 3 # 1 "/usr/include/c++/10/bits/refwrap.h" 1 3 # 33 "/usr/include/c++/10/bits/refwrap.h" 3 # 34 "/usr/include/c++/10/bits/refwrap.h" 3 # 43 "/usr/include/c++/10/bits/refwrap.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 54 "/usr/include/c++/10/bits/refwrap.h" 3 template struct _Maybe_unary_or_binary_function { }; template struct _Maybe_unary_or_binary_function<_Res, _T1> : std::unary_function<_T1, _Res> { }; template struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> : std::binary_function<_T1, _T2, _Res> { }; template struct _Mem_fn_traits; template struct _Mem_fn_traits_base { using __result_type = _Res; using __maybe_type = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; using __arity = integral_constant; }; # 99 "/usr/include/c++/10/bits/refwrap.h" 3 template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template> struct _Maybe_get_result_type { }; template struct _Maybe_get_result_type<_Functor, __void_t> { typedef typename _Functor::result_type result_type; }; template struct _Weak_result_type_impl : _Maybe_get_result_type<_Functor> { }; template struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> { typedef _Res result_type; }; template struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> { typedef _Res result_type; }; template struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> { typedef _Res result_type; }; template struct _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> { typedef _Res result_type; }; template::value> struct _Weak_result_type_memfun : _Weak_result_type_impl<_Functor> { }; template struct _Weak_result_type_memfun<_MemFunPtr, true> { using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; }; template struct _Weak_result_type_memfun<_Func _Class::*, false> { }; template struct _Weak_result_type : _Weak_result_type_memfun::type> { }; # 293 "/usr/include/c++/10/bits/refwrap.h" 3 template 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> using __not_same = typename enable_if::value>::type; public: typedef _Tp type; template, 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 constexpr typename result_of<_Tp&(_Args&&...)>::type operator()(_Args&&... __args) const { if constexpr (is_object_v) static_assert(sizeof(type), "type must be complete"); return std::__invoke(get(), std::forward<_Args>(__args)...); } }; template reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; template constexpr inline reference_wrapper<_Tp> ref(_Tp& __t) noexcept { return reference_wrapper<_Tp>(__t); } template constexpr inline reference_wrapper cref(const _Tp& __t) noexcept { return reference_wrapper(__t); } template void ref(const _Tp&&) = delete; template void cref(const _Tp&&) = delete; template constexpr inline reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept { return __t; } template constexpr inline reference_wrapper cref(reference_wrapper<_Tp> __t) noexcept { return { __t.get() }; } } # 59 "/usr/include/c++/10/functional" 2 3 # 1 "/usr/include/c++/10/bits/std_function.h" 1 3 # 33 "/usr/include/c++/10/bits/std_function.h" 3 # 34 "/usr/include/c++/10/bits/std_function.h" 3 # 47 "/usr/include/c++/10/bits/std_function.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { class bad_function_call : public std::exception { public: virtual ~bad_function_call() noexcept; const char* what() const noexcept; }; template struct __is_location_invariant : is_trivially_copyable<_Tp>::type { }; class _Undefined_class; union _Nocopy_types { void* _M_object; const void* _M_const_object; void (*_M_function_pointer)(); void (_Undefined_class::*_M_member_pointer)(); }; union [[gnu::may_alias]] _Any_data { void* _M_access() { return &_M_pod_data[0]; } const void* _M_access() const { return &_M_pod_data[0]; } template _Tp& _M_access() { return *static_cast<_Tp*>(_M_access()); } template const _Tp& _M_access() const { return *static_cast(_M_access()); } _Nocopy_types _M_unused; char _M_pod_data[sizeof(_Nocopy_types)]; }; enum _Manager_operation { __get_type_info, __get_functor_ptr, __clone_functor, __destroy_functor }; template class function; class _Function_base { public: static const size_t _M_max_size = sizeof(_Nocopy_types); static const size_t _M_max_align = __alignof__(_Nocopy_types); template class _Base_manager { protected: static const bool __stored_locally = (__is_location_invariant<_Functor>::value && sizeof(_Functor) <= _M_max_size && __alignof__(_Functor) <= _M_max_align && (_M_max_align % __alignof__(_Functor) == 0)); typedef integral_constant _Local_storage; static _Functor* _M_get_pointer(const _Any_data& __source) { if constexpr (__stored_locally) { const _Functor& __f = __source._M_access<_Functor>(); return const_cast<_Functor*>(std::__addressof(__f)); } else return __source._M_access<_Functor*>(); } static void _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) { ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); } static void _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) { __dest._M_access<_Functor*>() = new _Functor(*__source._M_access()); } static void _M_destroy(_Any_data& __victim, true_type) { __victim._M_access<_Functor>().~_Functor(); } static void _M_destroy(_Any_data& __victim, false_type) { delete __victim._M_access<_Functor*>(); } public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { switch (__op) { case __get_type_info: __dest._M_access() = &typeid(_Functor); break; case __get_functor_ptr: __dest._M_access<_Functor*>() = _M_get_pointer(__source); break; case __clone_functor: _M_clone(__dest, __source, _Local_storage()); break; case __destroy_functor: _M_destroy(__dest, _Local_storage()); break; } return false; } static void _M_init_functor(_Any_data& __functor, _Functor&& __f) { _M_init_functor(__functor, std::move(__f), _Local_storage()); } template static bool _M_not_empty_function(const function<_Signature>& __f) { return static_cast(__f); } template static bool _M_not_empty_function(_Tp* __fp) { return __fp != nullptr; } template static bool _M_not_empty_function(_Tp _Class::* __mp) { return __mp != nullptr; } template static bool _M_not_empty_function(const _Tp&) { return true; } private: static void _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) { ::new (__functor._M_access()) _Functor(std::move(__f)); } static void _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } }; _Function_base() : _M_manager(nullptr) { } ~_Function_base() { if (_M_manager) _M_manager(_M_functor, _M_functor, __destroy_functor); } bool _M_empty() const { return !_M_manager; } typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, _Manager_operation); _Any_data _M_functor; _Manager_type _M_manager; }; template class _Function_handler; template class _Function_handler<_Res(_ArgTypes...), _Functor> : public _Function_base::_Base_manager<_Functor> { typedef _Function_base::_Base_manager<_Functor> _Base; public: static bool _M_manager(_Any_data& __dest, const _Any_data& __source, _Manager_operation __op) { switch (__op) { case __get_type_info: __dest._M_access() = &typeid(_Functor); break; case __get_functor_ptr: __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source); break; default: _Base::_M_manager(__dest, __source, __op); } return false; } static _Res _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) { return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor), std::forward<_ArgTypes>(__args)...); } }; template class function<_Res(_ArgTypes...)> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, private _Function_base { template> struct _Callable : __is_invocable_impl<_Res2, _Res>::type { }; template struct _Callable : false_type { }; template using _Requires = typename enable_if<_Cond::value, _Tp>::type; public: typedef _Res result_type; function() noexcept : _Function_base() { } function(nullptr_t) noexcept : _Function_base() { } # 348 "/usr/include/c++/10/bits/std_function.h" 3 function(const function& __x); # 357 "/usr/include/c++/10/bits/std_function.h" 3 function(function&& __x) noexcept : _Function_base() { __x.swap(*this); } # 378 "/usr/include/c++/10/bits/std_function.h" 3 template>, void>, typename = _Requires<_Callable<_Functor>, void>> function(_Functor); # 395 "/usr/include/c++/10/bits/std_function.h" 3 function& operator=(const function& __x) { function(__x).swap(*this); return *this; } # 413 "/usr/include/c++/10/bits/std_function.h" 3 function& operator=(function&& __x) noexcept { function(std::move(__x)).swap(*this); return *this; } # 427 "/usr/include/c++/10/bits/std_function.h" 3 function& operator=(nullptr_t) noexcept { if (_M_manager) { _M_manager(_M_functor, _M_functor, __destroy_functor); _M_manager = nullptr; _M_invoker = nullptr; } return *this; } # 455 "/usr/include/c++/10/bits/std_function.h" 3 template _Requires<_Callable::type>, function&> operator=(_Functor&& __f) { function(std::forward<_Functor>(__f)).swap(*this); return *this; } template function& operator=(reference_wrapper<_Functor> __f) noexcept { function(__f).swap(*this); return *this; } # 481 "/usr/include/c++/10/bits/std_function.h" 3 void swap(function& __x) noexcept { std::swap(_M_functor, __x._M_functor); std::swap(_M_manager, __x._M_manager); std::swap(_M_invoker, __x._M_invoker); } # 498 "/usr/include/c++/10/bits/std_function.h" 3 explicit operator bool() const noexcept { return !_M_empty(); } # 511 "/usr/include/c++/10/bits/std_function.h" 3 _Res operator()(_ArgTypes... __args) const; # 524 "/usr/include/c++/10/bits/std_function.h" 3 const type_info& target_type() const noexcept; # 537 "/usr/include/c++/10/bits/std_function.h" 3 template _Functor* target() noexcept; template const _Functor* target() const noexcept; private: using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); _Invoker_type _M_invoker; }; template struct __function_guide_helper { }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) noexcept(_Nx) > { using type = _Res(_Args...); }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) & noexcept(_Nx) > { using type = _Res(_Args...); }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) const noexcept(_Nx) > { using type = _Res(_Args...); }; template struct __function_guide_helper< _Res (_Tp::*) (_Args...) const & noexcept(_Nx) > { using type = _Res(_Args...); }; template function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; template::type> function(_Functor) -> function<_Signature>; template function<_Res(_ArgTypes...)>:: function(const function& __x) : _Function_base() { if (static_cast(__x)) { __x._M_manager(_M_functor, __x._M_functor, __clone_functor); _M_invoker = __x._M_invoker; _M_manager = __x._M_manager; } } template template function<_Res(_ArgTypes...)>:: function(_Functor __f) : _Function_base() { typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler; if (_My_handler::_M_not_empty_function(__f)) { _My_handler::_M_init_functor(_M_functor, std::move(__f)); _M_invoker = &_My_handler::_M_invoke; _M_manager = &_My_handler::_M_manager; } } template _Res function<_Res(_ArgTypes...)>:: operator()(_ArgTypes... __args) const { if (_M_empty()) __throw_bad_function_call(); return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); } template const type_info& function<_Res(_ArgTypes...)>:: target_type() const noexcept { if (_M_manager) { _Any_data __typeinfo_result; _M_manager(__typeinfo_result, _M_functor, __get_type_info); return *__typeinfo_result._M_access(); } else return typeid(void); } template template _Functor* function<_Res(_ArgTypes...)>:: target() noexcept { const function* __const_this = this; const _Functor* __func = __const_this->template target<_Functor>(); return const_cast<_Functor*>(__func); } template template const _Functor* function<_Res(_ArgTypes...)>:: target() const noexcept { if (typeid(_Functor) == target_type() && _M_manager) { _Any_data __ptr; _M_manager(__ptr, _M_functor, __get_functor_ptr); return __ptr._M_access(); } else return nullptr; } # 678 "/usr/include/c++/10/bits/std_function.h" 3 template inline bool operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept { return !static_cast(__f); } # 718 "/usr/include/c++/10/bits/std_function.h" 3 template inline void swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept { __x.swap(__y); } namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::true_type { }; } } # 60 "/usr/include/c++/10/functional" 2 3 # 1 "/usr/include/c++/10/unordered_map" 1 3 # 32 "/usr/include/c++/10/unordered_map" 3 # 33 "/usr/include/c++/10/unordered_map" 3 # 42 "/usr/include/c++/10/unordered_map" 3 # 1 "/usr/include/c++/10/ext/aligned_buffer.h" 1 3 # 32 "/usr/include/c++/10/ext/aligned_buffer.h" 3 # 33 "/usr/include/c++/10/ext/aligned_buffer.h" 3 namespace __gnu_cxx { template struct __aligned_membuf { struct _Tp2 { _Tp _M_t; }; alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)]; __aligned_membuf() = default; __aligned_membuf(std::nullptr_t) { } void* _M_addr() noexcept { return static_cast(&_M_storage); } const void* _M_addr() const noexcept { return static_cast(&_M_storage); } _Tp* _M_ptr() noexcept { return static_cast<_Tp*>(_M_addr()); } const _Tp* _M_ptr() const noexcept { return static_cast(_M_addr()); } }; # 89 "/usr/include/c++/10/ext/aligned_buffer.h" 3 template struct __aligned_buffer : std::aligned_storage { typename std::aligned_storage::type _M_storage; __aligned_buffer() = default; __aligned_buffer(std::nullptr_t) { } void* _M_addr() noexcept { return static_cast(&_M_storage); } const void* _M_addr() const noexcept { return static_cast(&_M_storage); } _Tp* _M_ptr() noexcept { return static_cast<_Tp*>(_M_addr()); } const _Tp* _M_ptr() const noexcept { return static_cast(_M_addr()); } }; } # 43 "/usr/include/c++/10/unordered_map" 2 3 # 1 "/usr/include/c++/10/bits/hashtable.h" 1 3 # 33 "/usr/include/c++/10/bits/hashtable.h" 3 # 34 "/usr/include/c++/10/bits/hashtable.h" 3 # 1 "/usr/include/c++/10/bits/hashtable_policy.h" 1 3 # 38 "/usr/include/c++/10/bits/hashtable_policy.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class _Hashtable; namespace __detail { template struct _Hashtable_base; template inline typename std::iterator_traits<_Iterator>::difference_type __distance_fw(_Iterator __first, _Iterator __last, std::input_iterator_tag) { return __first != __last ? 1 : 0; } template inline typename std::iterator_traits<_Iterator>::difference_type __distance_fw(_Iterator __first, _Iterator __last, std::forward_iterator_tag) { return std::distance(__first, __last); } template inline typename std::iterator_traits<_Iterator>::difference_type __distance_fw(_Iterator __first, _Iterator __last) { return __distance_fw(__first, __last, std::__iterator_category(__first)); } struct _Identity { template _Tp&& operator()(_Tp&& __x) const { return std::forward<_Tp>(__x); } }; struct _Select1st { template auto operator()(_Tp&& __x) const -> decltype(std::get<0>(std::forward<_Tp>(__x))) { return std::get<0>(std::forward<_Tp>(__x)); } }; template struct _Hashtable_alloc; template struct _ReuseOrAllocNode { private: using __node_alloc_type = _NodeAlloc; using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>; using __node_alloc_traits = typename __hashtable_alloc::__node_alloc_traits; using __node_type = typename __hashtable_alloc::__node_type; public: _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h) : _M_nodes(__nodes), _M_h(__h) { } _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; ~_ReuseOrAllocNode() { _M_h._M_deallocate_nodes(_M_nodes); } template __node_type* operator()(_Arg&& __arg) const { if (_M_nodes) { __node_type* __node = _M_nodes; _M_nodes = _M_nodes->_M_next(); __node->_M_nxt = nullptr; auto& __a = _M_h._M_node_allocator(); __node_alloc_traits::destroy(__a, __node->_M_valptr()); try { __node_alloc_traits::construct(__a, __node->_M_valptr(), std::forward<_Arg>(__arg)); } catch(...) { _M_h._M_deallocate_node_ptr(__node); throw; } return __node; } return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); } private: mutable __node_type* _M_nodes; __hashtable_alloc& _M_h; }; template struct _AllocNode { private: using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>; using __node_type = typename __hashtable_alloc::__node_type; public: _AllocNode(__hashtable_alloc& __h) : _M_h(__h) { } template __node_type* operator()(_Arg&& __arg) const { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); } private: __hashtable_alloc& _M_h; }; # 198 "/usr/include/c++/10/bits/hashtable_policy.h" 3 template struct _Hashtable_traits { using __hash_cached = __bool_constant<_Cache_hash_code>; using __constant_iterators = __bool_constant<_Constant_iterators>; using __unique_keys = __bool_constant<_Unique_keys>; }; # 214 "/usr/include/c++/10/bits/hashtable_policy.h" 3 struct _Hash_node_base { _Hash_node_base* _M_nxt; _Hash_node_base() noexcept : _M_nxt() { } _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { } }; template struct _Hash_node_value_base : _Hash_node_base { typedef _Value value_type; __gnu_cxx::__aligned_buffer<_Value> _M_storage; _Value* _M_valptr() noexcept { return _M_storage._M_ptr(); } const _Value* _M_valptr() const noexcept { return _M_storage._M_ptr(); } _Value& _M_v() noexcept { return *_M_valptr(); } const _Value& _M_v() const noexcept { return *_M_valptr(); } }; template struct _Hash_node; template struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value> { std::size_t _M_hash_code; _Hash_node* _M_next() const noexcept { return static_cast<_Hash_node*>(this->_M_nxt); } }; template struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value> { _Hash_node* _M_next() const noexcept { return static_cast<_Hash_node*>(this->_M_nxt); } }; template struct _Node_iterator_base { using __node_type = _Hash_node<_Value, _Cache_hash_code>; __node_type* _M_cur; _Node_iterator_base(__node_type* __p) noexcept : _M_cur(__p) { } void _M_incr() noexcept { _M_cur = _M_cur->_M_next(); } }; template inline bool operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x, const _Node_iterator_base<_Value, _Cache_hash_code >& __y) noexcept { return __x._M_cur == __y._M_cur; } template inline bool operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x, const _Node_iterator_base<_Value, _Cache_hash_code>& __y) noexcept { return __x._M_cur != __y._M_cur; } template struct _Node_iterator : public _Node_iterator_base<_Value, __cache> { private: using __base_type = _Node_iterator_base<_Value, __cache>; using __node_type = typename __base_type::__node_type; public: typedef _Value value_type; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; using pointer = typename std::conditional<__constant_iterators, const _Value*, _Value*>::type; using reference = typename std::conditional<__constant_iterators, const _Value&, _Value&>::type; _Node_iterator() noexcept : __base_type(0) { } explicit _Node_iterator(__node_type* __p) noexcept : __base_type(__p) { } reference operator*() const noexcept { return this->_M_cur->_M_v(); } pointer operator->() const noexcept { return this->_M_cur->_M_valptr(); } _Node_iterator& operator++() noexcept { this->_M_incr(); return *this; } _Node_iterator operator++(int) noexcept { _Node_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; template struct _Node_const_iterator : public _Node_iterator_base<_Value, __cache> { private: using __base_type = _Node_iterator_base<_Value, __cache>; using __node_type = typename __base_type::__node_type; public: typedef _Value value_type; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; typedef const _Value* pointer; typedef const _Value& reference; _Node_const_iterator() noexcept : __base_type(0) { } explicit _Node_const_iterator(__node_type* __p) noexcept : __base_type(__p) { } _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators, __cache>& __x) noexcept : __base_type(__x._M_cur) { } reference operator*() const noexcept { return this->_M_cur->_M_v(); } pointer operator->() const noexcept { return this->_M_cur->_M_valptr(); } _Node_const_iterator& operator++() noexcept { this->_M_incr(); return *this; } _Node_const_iterator operator++(int) noexcept { _Node_const_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; struct _Mod_range_hashing { typedef std::size_t first_argument_type; typedef std::size_t second_argument_type; typedef std::size_t result_type; result_type operator()(first_argument_type __num, second_argument_type __den) const noexcept { return __num % __den; } }; struct _Default_ranged_hash { }; struct _Prime_rehash_policy { using __has_load_factor = true_type; _Prime_rehash_policy(float __z = 1.0) noexcept : _M_max_load_factor(__z), _M_next_resize(0) { } float max_load_factor() const noexcept { return _M_max_load_factor; } std::size_t _M_next_bkt(std::size_t __n) const; std::size_t _M_bkt_for_elements(std::size_t __n) const { return __builtin_ceill(__n / (long double)_M_max_load_factor); } std::pair _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, std::size_t __n_ins) const; typedef std::size_t _State; _State _M_state() const { return _M_next_resize; } void _M_reset() noexcept { _M_next_resize = 0; } void _M_reset(_State __state) { _M_next_resize = __state; } static const std::size_t _S_growth_factor = 2; float _M_max_load_factor; mutable std::size_t _M_next_resize; }; struct _Mask_range_hashing { typedef std::size_t first_argument_type; typedef std::size_t second_argument_type; typedef std::size_t result_type; result_type operator()(first_argument_type __num, second_argument_type __den) const noexcept { return __num & (__den - 1); } }; inline std::size_t __clp2(std::size_t __n) noexcept { if (__n < 2) return __n; const unsigned __lz = sizeof(size_t) > sizeof(long) ? __builtin_clzll(__n - 1ull) : __builtin_clzl(__n - 1ul); return (size_t(1) << (numeric_limits::digits - __lz - 1)) << 1; } struct _Power2_rehash_policy { using __has_load_factor = true_type; _Power2_rehash_policy(float __z = 1.0) noexcept : _M_max_load_factor(__z), _M_next_resize(0) { } float max_load_factor() const noexcept { return _M_max_load_factor; } std::size_t _M_next_bkt(std::size_t __n) noexcept { if (__n == 0) return 1; const auto __max_width = std::min(sizeof(size_t), 8); const auto __max_bkt = size_t(1) << (__max_width * 8 - 1); std::size_t __res = __clp2(__n); if (__res == 0) __res = __max_bkt; else if (__res == 1) __res = 2; if (__res == __max_bkt) _M_next_resize = numeric_limits::max(); else _M_next_resize = __builtin_floorl(__res * (long double)_M_max_load_factor); return __res; } std::size_t _M_bkt_for_elements(std::size_t __n) const noexcept { return __builtin_ceill(__n / (long double)_M_max_load_factor); } std::pair _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, std::size_t __n_ins) noexcept { if (__n_elt + __n_ins > _M_next_resize) { long double __min_bkts = std::max(__n_elt + __n_ins, _M_next_resize ? 0 : 11) / (long double)_M_max_load_factor; if (__min_bkts >= __n_bkt) return { true, _M_next_bkt(std::max(__builtin_floorl(__min_bkts) + 1, __n_bkt * _S_growth_factor)) }; _M_next_resize = __builtin_floorl(__n_bkt * (long double)_M_max_load_factor); return { false, 0 }; } else return { false, 0 }; } typedef std::size_t _State; _State _M_state() const noexcept { return _M_next_resize; } void _M_reset() noexcept { _M_next_resize = 0; } void _M_reset(_State __state) noexcept { _M_next_resize = __state; } static const std::size_t _S_growth_factor = 2; float _M_max_load_factor; std::size_t _M_next_resize; }; # 640 "/usr/include/c++/10/bits/hashtable_policy.h" 3 template struct _Map_base { }; template struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false> { using mapped_type = typename std::tuple_element<1, _Pair>::type; }; template struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true> { private: using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair, _Select1st, _Equal, _H1, _H2, _Hash, _Traits>; using __hashtable = _Hashtable<_Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; using __hash_code = typename __hashtable_base::__hash_code; using __node_type = typename __hashtable_base::__node_type; public: using key_type = typename __hashtable_base::key_type; using iterator = typename __hashtable_base::iterator; using mapped_type = typename std::tuple_element<1, _Pair>::type; mapped_type& operator[](const key_type& __k); mapped_type& operator[](key_type&& __k); mapped_type& at(const key_type& __k); const mapped_type& at(const key_type& __k) const; }; template auto _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: operator[](const key_type& __k) -> mapped_type& { __hashtable* __h = static_cast<__hashtable*>(this); __hash_code __code = __h->_M_hash_code(__k); std::size_t __bkt = __h->_M_bucket_index(__k, __code); if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code)) return __node->_M_v().second; typename __hashtable::_Scoped_node __node { __h, std::piecewise_construct, std::tuple(__k), std::tuple<>() }; auto __pos = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node); __node._M_node = nullptr; return __pos->second; } template auto _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: operator[](key_type&& __k) -> mapped_type& { __hashtable* __h = static_cast<__hashtable*>(this); __hash_code __code = __h->_M_hash_code(__k); std::size_t __bkt = __h->_M_bucket_index(__k, __code); if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code)) return __node->_M_v().second; typename __hashtable::_Scoped_node __node { __h, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::tuple<>() }; auto __pos = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node); __node._M_node = nullptr; return __pos->second; } template auto _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: at(const key_type& __k) -> mapped_type& { __hashtable* __h = static_cast<__hashtable*>(this); __hash_code __code = __h->_M_hash_code(__k); std::size_t __bkt = __h->_M_bucket_index(__k, __code); __node_type* __p = __h->_M_find_node(__bkt, __k, __code); if (!__p) __throw_out_of_range(("_Map_base::at")); return __p->_M_v().second; } template auto _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: at(const key_type& __k) const -> const mapped_type& { const __hashtable* __h = static_cast(this); __hash_code __code = __h->_M_hash_code(__k); std::size_t __bkt = __h->_M_bucket_index(__k, __code); __node_type* __p = __h->_M_find_node(__bkt, __k, __code); if (!__p) __throw_out_of_range(("_Map_base::at")); return __p->_M_v().second; } template struct _Insert_base { protected: using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits>; using value_type = typename __hashtable_base::value_type; using iterator = typename __hashtable_base::iterator; using const_iterator = typename __hashtable_base::const_iterator; using size_type = typename __hashtable_base::size_type; using __unique_keys = typename __hashtable_base::__unique_keys; using __ireturn_type = typename __hashtable_base::__ireturn_type; using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>; using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>; using __node_gen_type = _AllocNode<__node_alloc_type>; __hashtable& _M_conjure_hashtable() { return *(static_cast<__hashtable*>(this)); } template void _M_insert_range(_InputIterator __first, _InputIterator __last, const _NodeGetter&, true_type); template void _M_insert_range(_InputIterator __first, _InputIterator __last, const _NodeGetter&, false_type); public: __ireturn_type insert(const value_type& __v) { __hashtable& __h = _M_conjure_hashtable(); __node_gen_type __node_gen(__h); return __h._M_insert(__v, __node_gen, __unique_keys()); } iterator insert(const_iterator __hint, const value_type& __v) { __hashtable& __h = _M_conjure_hashtable(); __node_gen_type __node_gen(__h); return __h._M_insert(__hint, __v, __node_gen, __unique_keys()); } void insert(initializer_list __l) { this->insert(__l.begin(), __l.end()); } template void insert(_InputIterator __first, _InputIterator __last) { __hashtable& __h = _M_conjure_hashtable(); __node_gen_type __node_gen(__h); return _M_insert_range(__first, __last, __node_gen, __unique_keys()); } }; template template void _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_insert_range(_InputIterator __first, _InputIterator __last, const _NodeGetter& __node_gen, true_type) { size_type __n_elt = __detail::__distance_fw(__first, __last); if (__n_elt == 0) return; __hashtable& __h = _M_conjure_hashtable(); for (; __first != __last; ++__first) { if (__h._M_insert(*__first, __node_gen, __unique_keys(), __n_elt).second) __n_elt = 1; else if (__n_elt != 1) --__n_elt; } } template template void _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_insert_range(_InputIterator __first, _InputIterator __last, const _NodeGetter& __node_gen, false_type) { using __rehash_type = typename __hashtable::__rehash_type; using __rehash_state = typename __hashtable::__rehash_state; using pair_type = std::pair; size_type __n_elt = __detail::__distance_fw(__first, __last); if (__n_elt == 0) return; __hashtable& __h = _M_conjure_hashtable(); __rehash_type& __rehash = __h._M_rehash_policy; const __rehash_state& __saved_state = __rehash._M_state(); pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count, __h._M_element_count, __n_elt); if (__do_rehash.first) __h._M_rehash(__do_rehash.second, __saved_state); for (; __first != __last; ++__first) __h._M_insert(*__first, __node_gen, __unique_keys()); } template struct _Insert; template struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true> : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits> { using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits>; using value_type = typename __base_type::value_type; using iterator = typename __base_type::iterator; using const_iterator = typename __base_type::const_iterator; using __unique_keys = typename __base_type::__unique_keys; using __ireturn_type = typename __hashtable_base::__ireturn_type; using __hashtable = typename __base_type::__hashtable; using __node_gen_type = typename __base_type::__node_gen_type; using __base_type::insert; __ireturn_type insert(value_type&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); __node_gen_type __node_gen(__h); return __h._M_insert(std::move(__v), __node_gen, __unique_keys()); } iterator insert(const_iterator __hint, value_type&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); __node_gen_type __node_gen(__h); return __h._M_insert(__hint, std::move(__v), __node_gen, __unique_keys()); } }; template struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false> : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits> { using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; using value_type = typename __base_type::value_type; using iterator = typename __base_type::iterator; using const_iterator = typename __base_type::const_iterator; using __unique_keys = typename __base_type::__unique_keys; using __hashtable = typename __base_type::__hashtable; using __ireturn_type = typename __base_type::__ireturn_type; using __base_type::insert; template using __is_cons = std::is_constructible; template using _IFcons = std::enable_if<__is_cons<_Pair>::value>; template using _IFconsp = typename _IFcons<_Pair>::type; template> __ireturn_type insert(_Pair&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v)); } template> iterator insert(const_iterator __hint, _Pair&& __v) { __hashtable& __h = this->_M_conjure_hashtable(); return __h._M_emplace(__hint, __unique_keys(), std::forward<_Pair>(__v)); } }; template using __has_load_factor = typename _Policy::__has_load_factor; template> struct _Rehash_base; template struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false_type> { }; template struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true_type> { using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; float max_load_factor() const noexcept { const __hashtable* __this = static_cast(this); return __this->__rehash_policy().max_load_factor(); } void max_load_factor(float __z) { __hashtable* __this = static_cast<__hashtable*>(this); __this->__rehash_policy(_RehashPolicy(__z)); } void reserve(std::size_t __n) { __hashtable* __this = static_cast<__hashtable*>(this); __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n)); } }; template struct _Hashtable_ebo_helper; template struct _Hashtable_ebo_helper<_Nm, _Tp, true> : private _Tp { _Hashtable_ebo_helper() = default; template _Hashtable_ebo_helper(_OtherTp&& __tp) : _Tp(std::forward<_OtherTp>(__tp)) { } const _Tp& _M_cget() const { return static_cast(*this); } _Tp& _M_get() { return static_cast<_Tp&>(*this); } }; template struct _Hashtable_ebo_helper<_Nm, _Tp, false> { _Hashtable_ebo_helper() = default; template _Hashtable_ebo_helper(_OtherTp&& __tp) : _M_tp(std::forward<_OtherTp>(__tp)) { } const _Tp& _M_cget() const { return _M_tp; } _Tp& _M_get() { return _M_tp; } private: _Tp _M_tp; }; template struct _Local_iterator_base; # 1172 "/usr/include/c++/10/bits/hashtable_policy.h" 3 template struct _Hash_code_base; template struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false> : private _Hashtable_ebo_helper<0, _ExtractKey>, private _Hashtable_ebo_helper<1, _Hash> { private: using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>; protected: typedef void* __hash_code; typedef _Hash_node<_Value, false> __node_type; _Hash_code_base() = default; _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&, const _Hash& __h) : __ebo_extract_key(__ex), __ebo_hash(__h) { } __hash_code _M_hash_code(const _Key& __key) const { return 0; } std::size_t _M_bucket_index(const _Key& __k, __hash_code, std::size_t __bkt_count) const { return _M_ranged_hash()(__k, __bkt_count); } std::size_t _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const noexcept( noexcept(declval()(declval(), (std::size_t)0)) ) { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __bkt_count); } void _M_store_code(__node_type*, __hash_code) const { } void _M_copy_code(__node_type*, const __node_type*) const { } void _M_swap(_Hash_code_base& __x) { std::swap(__ebo_extract_key::_M_get(), __x.__ebo_extract_key::_M_get()); std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get()); } const _ExtractKey& _M_extract() const { return __ebo_extract_key::_M_cget(); } const _Hash& _M_ranged_hash() const { return __ebo_hash::_M_cget(); } }; template struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>; template struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false> : private _Hashtable_ebo_helper<0, _ExtractKey>, private _Hashtable_ebo_helper<1, _H1>, private _Hashtable_ebo_helper<2, _H2> { private: using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>; using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>; friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, false>; public: typedef _H1 hasher; hasher hash_function() const { return _M_h1(); } protected: typedef std::size_t __hash_code; typedef _Hash_node<_Value, false> __node_type; _Hash_code_base() = default; _Hash_code_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2, const _Default_ranged_hash&) : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { } __hash_code _M_hash_code(const _Key& __k) const { static_assert(__is_invocable{}, "hash function must be invocable with an argument of key type"); return _M_h1()(__k); } std::size_t _M_bucket_index(const _Key&, __hash_code __c, std::size_t __bkt_count) const { return _M_h2()(__c, __bkt_count); } std::size_t _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const noexcept( noexcept(declval()(declval())) && noexcept(declval()((__hash_code)0, (std::size_t)0)) ) { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __bkt_count); } void _M_store_code(__node_type*, __hash_code) const { } void _M_copy_code(__node_type*, const __node_type*) const { } void _M_swap(_Hash_code_base& __x) { std::swap(__ebo_extract_key::_M_get(), __x.__ebo_extract_key::_M_get()); std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get()); std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get()); } const _ExtractKey& _M_extract() const { return __ebo_extract_key::_M_cget(); } const _H1& _M_h1() const { return __ebo_h1::_M_cget(); } const _H2& _M_h2() const { return __ebo_h2::_M_cget(); } }; template struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true> : private _Hashtable_ebo_helper<0, _ExtractKey>, private _Hashtable_ebo_helper<1, _H1>, private _Hashtable_ebo_helper<2, _H2> { private: friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Default_ranged_hash, true>; using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>; using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>; public: typedef _H1 hasher; hasher hash_function() const { return _M_h1(); } protected: typedef std::size_t __hash_code; typedef _Hash_node<_Value, true> __node_type; _Hash_code_base() = default; _Hash_code_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2, const _Default_ranged_hash&) : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { } __hash_code _M_hash_code(const _Key& __k) const { static_assert(__is_invocable{}, "hash function must be invocable with an argument of key type"); return _M_h1()(__k); } std::size_t _M_bucket_index(const _Key&, __hash_code __c, std::size_t __bkt_count) const { return _M_h2()(__c, __bkt_count); } std::size_t _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const noexcept( noexcept(declval()((__hash_code)0, (std::size_t)0)) ) { return _M_h2()(__p->_M_hash_code, __bkt_count); } void _M_store_code(__node_type* __n, __hash_code __c) const { __n->_M_hash_code = __c; } void _M_copy_code(__node_type* __to, const __node_type* __from) const { __to->_M_hash_code = __from->_M_hash_code; } void _M_swap(_Hash_code_base& __x) { std::swap(__ebo_extract_key::_M_get(), __x.__ebo_extract_key::_M_get()); std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get()); std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get()); } const _ExtractKey& _M_extract() const { return __ebo_extract_key::_M_cget(); } const _H1& _M_h1() const { return __ebo_h1::_M_cget(); } const _H2& _M_h2() const { return __ebo_h2::_M_cget(); } }; template struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true> : private _Hashtable_ebo_helper<0, _H2> { protected: using __base_type = _Hashtable_ebo_helper<0, _H2>; using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>; _Local_iterator_base() = default; _Local_iterator_base(const __hash_code_base& __base, _Hash_node<_Value, true>* __p, std::size_t __bkt, std::size_t __bkt_count) : __base_type(__base._M_h2()), _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { } void _M_incr() { _M_cur = _M_cur->_M_next(); if (_M_cur) { std::size_t __bkt = __base_type::_M_get()(_M_cur->_M_hash_code, _M_bucket_count); if (__bkt != _M_bucket) _M_cur = nullptr; } } _Hash_node<_Value, true>* _M_cur; std::size_t _M_bucket; std::size_t _M_bucket_count; public: const void* _M_curr() const { return _M_cur; } std::size_t _M_get_bucket() const { return _M_bucket; } }; template::value> struct _Hash_code_storage { __gnu_cxx::__aligned_buffer<_Tp> _M_storage; _Tp* _M_h() { return _M_storage._M_ptr(); } const _Tp* _M_h() const { return _M_storage._M_ptr(); } }; template struct _Hash_code_storage<_Tp, true> { static_assert( std::is_empty<_Tp>::value, "Type must be empty" ); _Tp* _M_h() { return reinterpret_cast<_Tp*>(this); } const _Tp* _M_h() const { return reinterpret_cast(this); } }; template using __hash_code_for_local_iter = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>>; template struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false> : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash> { protected: using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>; _Local_iterator_base() : _M_bucket_count(-1) { } _Local_iterator_base(const __hash_code_base& __base, _Hash_node<_Value, false>* __p, std::size_t __bkt, std::size_t __bkt_count) : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { _M_init(__base); } ~_Local_iterator_base() { if (_M_bucket_count != -1) _M_destroy(); } _Local_iterator_base(const _Local_iterator_base& __iter) : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket), _M_bucket_count(__iter._M_bucket_count) { if (_M_bucket_count != -1) _M_init(*__iter._M_h()); } _Local_iterator_base& operator=(const _Local_iterator_base& __iter) { if (_M_bucket_count != -1) _M_destroy(); _M_cur = __iter._M_cur; _M_bucket = __iter._M_bucket; _M_bucket_count = __iter._M_bucket_count; if (_M_bucket_count != -1) _M_init(*__iter._M_h()); return *this; } void _M_incr() { _M_cur = _M_cur->_M_next(); if (_M_cur) { std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur, _M_bucket_count); if (__bkt != _M_bucket) _M_cur = nullptr; } } _Hash_node<_Value, false>* _M_cur; std::size_t _M_bucket; std::size_t _M_bucket_count; void _M_init(const __hash_code_base& __base) { ::new(this->_M_h()) __hash_code_base(__base); } void _M_destroy() { this->_M_h()->~__hash_code_base(); } public: const void* _M_curr() const { return _M_cur; } std::size_t _M_get_bucket() const { return _M_bucket; } }; template inline bool operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache>& __x, const _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache>& __y) { return __x._M_curr() == __y._M_curr(); } template inline bool operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache>& __x, const _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache>& __y) { return __x._M_curr() != __y._M_curr(); } template struct _Local_iterator : public _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache> { private: using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache>; using __hash_code_base = typename __base_type::__hash_code_base; public: typedef _Value value_type; typedef typename std::conditional<__constant_iterators, const _Value*, _Value*>::type pointer; typedef typename std::conditional<__constant_iterators, const _Value&, _Value&>::type reference; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Local_iterator() = default; _Local_iterator(const __hash_code_base& __base, _Hash_node<_Value, __cache>* __n, std::size_t __bkt, std::size_t __bkt_count) : __base_type(__base, __n, __bkt, __bkt_count) { } reference operator*() const { return this->_M_cur->_M_v(); } pointer operator->() const { return this->_M_cur->_M_valptr(); } _Local_iterator& operator++() { this->_M_incr(); return *this; } _Local_iterator operator++(int) { _Local_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; template struct _Local_const_iterator : public _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache> { private: using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __cache>; using __hash_code_base = typename __base_type::__hash_code_base; public: typedef _Value value_type; typedef const _Value* pointer; typedef const _Value& reference; typedef std::ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Local_const_iterator() = default; _Local_const_iterator(const __hash_code_base& __base, _Hash_node<_Value, __cache>* __n, std::size_t __bkt, std::size_t __bkt_count) : __base_type(__base, __n, __bkt, __bkt_count) { } _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __constant_iterators, __cache>& __x) : __base_type(__x) { } reference operator*() const { return this->_M_cur->_M_v(); } pointer operator->() const { return this->_M_cur->_M_valptr(); } _Local_const_iterator& operator++() { this->_M_incr(); return *this; } _Local_const_iterator operator++(int) { _Local_const_iterator __tmp(*this); this->_M_incr(); return __tmp; } }; # 1722 "/usr/include/c++/10/bits/hashtable_policy.h" 3 template struct _Hashtable_base : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, _Traits::__hash_cached::value>, private _Hashtable_ebo_helper<0, _Equal> { public: typedef _Key key_type; typedef _Value value_type; typedef _Equal key_equal; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; using __traits_type = _Traits; using __hash_cached = typename __traits_type::__hash_cached; using __constant_iterators = typename __traits_type::__constant_iterators; using __unique_keys = typename __traits_type::__unique_keys; using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, __hash_cached::value>; using __hash_code = typename __hash_code_base::__hash_code; using __node_type = typename __hash_code_base::__node_type; using iterator = __detail::_Node_iterator; using const_iterator = __detail::_Node_const_iterator; using local_iterator = __detail::_Local_iterator; using const_local_iterator = __detail::_Local_const_iterator; using __ireturn_type = typename std::conditional<__unique_keys::value, std::pair, iterator>::type; private: using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>; template struct _Equal_hash_code { static bool _S_equals(__hash_code, const _NodeT&) { return true; } }; template struct _Equal_hash_code<_Hash_node<_Ptr2, true>> { static bool _S_equals(__hash_code __c, const _Hash_node<_Ptr2, true>& __n) { return __c == __n._M_hash_code; } }; protected: _Hashtable_base() = default; _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2, const _Hash& __hash, const _Equal& __eq) : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq) { } bool _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const { static_assert(__is_invocable{}, "key equality predicate must be invocable with two arguments of " "key type"); return _Equal_hash_code<__node_type>::_S_equals(__c, *__n) && _M_eq()(__k, this->_M_extract()(__n->_M_v())); } void _M_swap(_Hashtable_base& __x) { __hash_code_base::_M_swap(__x); std::swap(_EqualEBO::_M_get(), __x._EqualEBO::_M_get()); } const _Equal& _M_eq() const { return _EqualEBO::_M_cget(); } }; # 1826 "/usr/include/c++/10/bits/hashtable_policy.h" 3 template struct _Equality; template struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true> { using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; bool _M_equal(const __hashtable&) const; }; template bool _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: _M_equal(const __hashtable& __other) const { using __node_base = typename __hashtable::__node_base; using __node_type = typename __hashtable::__node_type; const __hashtable* __this = static_cast(this); if (__this->size() != __other.size()) return false; for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx) { std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur); __node_base* __prev_n = __other._M_buckets[__ybkt]; if (!__prev_n) return false; for (__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);; __n = __n->_M_next()) { if (__n->_M_v() == *__itx) break; if (!__n->_M_nxt || __other._M_bucket_index(__n->_M_next()) != __ybkt) return false; } } return true; } template struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false> { using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; bool _M_equal(const __hashtable&) const; }; template bool _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits, false>:: _M_equal(const __hashtable& __other) const { using __node_base = typename __hashtable::__node_base; using __node_type = typename __hashtable::__node_type; const __hashtable* __this = static_cast(this); if (__this->size() != __other.size()) return false; for (auto __itx = __this->begin(); __itx != __this->end();) { std::size_t __x_count = 1; auto __itx_end = __itx; for (++__itx_end; __itx_end != __this->end() && __this->key_eq()(_ExtractKey()(*__itx), _ExtractKey()(*__itx_end)); ++__itx_end) ++__x_count; std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur); __node_base* __y_prev_n = __other._M_buckets[__ybkt]; if (!__y_prev_n) return false; __node_type* __y_n = static_cast<__node_type*>(__y_prev_n->_M_nxt); for (;; __y_n = __y_n->_M_next()) { if (__this->key_eq()(_ExtractKey()(__y_n->_M_v()), _ExtractKey()(*__itx))) break; if (!__y_n->_M_nxt || __other._M_bucket_index(__y_n->_M_next()) != __ybkt) return false; } typename __hashtable::const_iterator __ity(__y_n); for (auto __ity_end = __ity; __ity_end != __other.end(); ++__ity_end) if (--__x_count == 0) break; if (__x_count != 0) return false; if (!std::is_permutation(__itx, __itx_end, __ity)) return false; __itx = __itx_end; } return true; } template struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc> { private: using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>; public: using __node_type = typename _NodeAlloc::value_type; using __node_alloc_type = _NodeAlloc; using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>; using __value_alloc_traits = typename __node_alloc_traits::template rebind_traits; using __node_base = __detail::_Hash_node_base; using __bucket_type = __node_base*; using __bucket_alloc_type = __alloc_rebind<__node_alloc_type, __bucket_type>; using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>; _Hashtable_alloc() = default; _Hashtable_alloc(const _Hashtable_alloc&) = default; _Hashtable_alloc(_Hashtable_alloc&&) = default; template _Hashtable_alloc(_Alloc&& __a) : __ebo_node_alloc(std::forward<_Alloc>(__a)) { } __node_alloc_type& _M_node_allocator() { return __ebo_node_alloc::_M_get(); } const __node_alloc_type& _M_node_allocator() const { return __ebo_node_alloc::_M_cget(); } template __node_type* _M_allocate_node(_Args&&... __args); void _M_deallocate_node(__node_type* __n); void _M_deallocate_node_ptr(__node_type* __n); void _M_deallocate_nodes(__node_type* __n); __bucket_type* _M_allocate_buckets(std::size_t __bkt_count); void _M_deallocate_buckets(__bucket_type*, std::size_t __bkt_count); }; template template auto _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args) -> __node_type* { auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1); __node_type* __n = std::__to_address(__nptr); try { ::new ((void*)__n) __node_type; __node_alloc_traits::construct(_M_node_allocator(), __n->_M_valptr(), std::forward<_Args>(__args)...); return __n; } catch(...) { __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1); throw; } } template void _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n) { __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr()); _M_deallocate_node_ptr(__n); } template void _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_type* __n) { typedef typename __node_alloc_traits::pointer _Ptr; auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n); __n->~__node_type(); __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1); } template void _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n) { while (__n) { __node_type* __tmp = __n; __n = __n->_M_next(); _M_deallocate_node(__tmp); } } template typename _Hashtable_alloc<_NodeAlloc>::__bucket_type* _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_count) { __bucket_alloc_type __alloc(_M_node_allocator()); auto __ptr = __bucket_alloc_traits::allocate(__alloc, __bkt_count); __bucket_type* __p = std::__to_address(__ptr); __builtin_memset(__p, 0, __bkt_count * sizeof(__bucket_type)); return __p; } template void _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts, std::size_t __bkt_count) { typedef typename __bucket_alloc_traits::pointer _Ptr; auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts); __bucket_alloc_type __alloc(_M_node_allocator()); __bucket_alloc_traits::deallocate(__alloc, __ptr, __bkt_count); } } } # 36 "/usr/include/c++/10/bits/hashtable.h" 2 3 # 1 "/usr/include/c++/10/bits/node_handle.h" 1 3 # 34 "/usr/include/c++/10/bits/node_handle.h" 3 # 35 "/usr/include/c++/10/bits/node_handle.h" 3 # 1 "/usr/include/c++/10/optional" 1 3 # 32 "/usr/include/c++/10/optional" 3 # 33 "/usr/include/c++/10/optional" 3 # 43 "/usr/include/c++/10/optional" 3 # 1 "/usr/include/c++/10/bits/enable_special_members.h" 1 3 # 33 "/usr/include/c++/10/bits/enable_special_members.h" 3 # 34 "/usr/include/c++/10/bits/enable_special_members.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct _Enable_default_constructor_tag { explicit constexpr _Enable_default_constructor_tag() = default; }; template 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 struct _Enable_destructor { }; template struct _Enable_copy_move { }; # 93 "/usr/include/c++/10/bits/enable_special_members.h" 3 template 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 struct _Enable_default_constructor { 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 struct _Enable_destructor { ~_Enable_destructor() noexcept = delete; }; template struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { 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 struct _Enable_copy_move { constexpr _Enable_copy_move() noexcept = default; constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move const&) noexcept = delete; _Enable_copy_move& operator=(_Enable_copy_move&&) noexcept = delete; }; } # 44 "/usr/include/c++/10/optional" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 59 "/usr/include/c++/10/optional" 3 template class optional; struct nullopt_t { enum class _Construct { _Token }; explicit constexpr nullopt_t(_Construct) { } }; inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token }; class bad_optional_access : public exception { public: bad_optional_access() = default; virtual ~bad_optional_access() = default; const char* what() const noexcept override { return "bad optional access"; } }; void __throw_bad_optional_access() __attribute__((__noreturn__)); inline void __throw_bad_optional_access() { (throw (bad_optional_access())); } template struct _Optional_payload_base { using _Stored_type = remove_const_t<_Tp>; _Optional_payload_base() = default; ~_Optional_payload_base() = default; template constexpr _Optional_payload_base(in_place_t __tag, _Args&&... __args) : _M_payload(__tag, std::forward<_Args>(__args)...), _M_engaged(true) { } template constexpr _Optional_payload_base(std::initializer_list<_Up> __il, _Args&&... __args) : _M_payload(__il, std::forward<_Args>(__args)...), _M_engaged(true) { } constexpr _Optional_payload_base(bool __engaged, const _Optional_payload_base& __other) { if (__other._M_engaged) this->_M_construct(__other._M_get()); } constexpr _Optional_payload_base(bool __engaged, _Optional_payload_base&& __other) { if (__other._M_engaged) this->_M_construct(std::move(__other._M_get())); } _Optional_payload_base(const _Optional_payload_base&) = default; _Optional_payload_base(_Optional_payload_base&&) = default; _Optional_payload_base& operator=(const _Optional_payload_base&) = default; _Optional_payload_base& operator=(_Optional_payload_base&&) = default; constexpr void _M_copy_assign(const _Optional_payload_base& __other) { if (this->_M_engaged && __other._M_engaged) this->_M_get() = __other._M_get(); else { if (__other._M_engaged) this->_M_construct(__other._M_get()); else this->_M_reset(); } } constexpr void _M_move_assign(_Optional_payload_base&& __other) noexcept(__and_v, is_nothrow_move_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> union _Storage { constexpr _Storage() noexcept : _M_empty() { } template constexpr _Storage(in_place_t, _Args&&... __args) : _M_value(std::forward<_Args>(__args)...) { } template constexpr _Storage(std::initializer_list<_Vp> __il, _Args&&... __args) : _M_value(__il, std::forward<_Args>(__args)...) { } _Empty_byte _M_empty; _Up _M_value; }; template union _Storage<_Up, false> { constexpr _Storage() noexcept : _M_empty() { } template constexpr _Storage(in_place_t, _Args&&... __args) : _M_value(std::forward<_Args>(__args)...) { } template constexpr _Storage(std::initializer_list<_Vp> __il, _Args&&... __args) : _M_value(__il, std::forward<_Args>(__args)...) { } ~_Storage() { } _Empty_byte _M_empty; _Up _M_value; }; _Storage<_Stored_type> _M_payload; bool _M_engaged = false; template void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>) { ::new ((void *) std::__addressof(this->_M_payload)) _Stored_type(std::forward<_Args>(__args)...); this->_M_engaged = true; } constexpr void _M_destroy() noexcept { _M_engaged = false; _M_payload._M_value.~_Stored_type(); } constexpr _Tp& _M_get() noexcept { return this->_M_payload._M_value; } constexpr const _Tp& _M_get() const noexcept { return this->_M_payload._M_value; } constexpr void _M_reset() noexcept { if (this->_M_engaged) _M_destroy(); } }; template , 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 struct _Optional_payload<_Tp, true, true, true> : _Optional_payload_base<_Tp> { using _Optional_payload_base<_Tp>::_Optional_payload_base; _Optional_payload() = default; }; template 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 struct _Optional_payload<_Tp, true, true, false> : _Optional_payload_base<_Tp> { using _Optional_payload_base<_Tp>::_Optional_payload_base; _Optional_payload() = default; ~_Optional_payload() = default; _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; _Optional_payload& operator=(const _Optional_payload&) = default; constexpr _Optional_payload& operator=(_Optional_payload&& __other) noexcept(__and_v, is_nothrow_move_assignable<_Tp>>) { this->_M_move_assign(std::move(__other)); return *this; } }; template struct _Optional_payload<_Tp, true, false, false> : _Optional_payload_base<_Tp> { using _Optional_payload_base<_Tp>::_Optional_payload_base; _Optional_payload() = default; ~_Optional_payload() = default; _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; constexpr _Optional_payload& operator=(const _Optional_payload& __other) { this->_M_copy_assign(__other); return *this; } constexpr _Optional_payload& operator=(_Optional_payload&& __other) noexcept(__and_v, is_nothrow_move_assignable<_Tp>>) { this->_M_move_assign(std::move(__other)); return *this; } }; template struct _Optional_payload<_Tp, false, _Copy, _Move> : _Optional_payload<_Tp, true, false, false> { using _Optional_payload<_Tp, true, false, false>::_Optional_payload; _Optional_payload() = default; _Optional_payload(const _Optional_payload&) = default; _Optional_payload(_Optional_payload&&) = default; _Optional_payload& operator=(const _Optional_payload&) = default; _Optional_payload& operator=(_Optional_payload&&) = default; ~_Optional_payload() { this->_M_reset(); } }; template class _Optional_base_impl { protected: using _Stored_type = remove_const_t<_Tp>; template void _M_construct(_Args&&... __args) noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>) { ::new (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload)) _Stored_type(std::forward<_Args>(__args)...); static_cast<_Dp*>(this)->_M_payload._M_engaged = true; } void _M_destruct() noexcept { static_cast<_Dp*>(this)->_M_payload._M_destroy(); } constexpr void _M_reset() noexcept { static_cast<_Dp*>(this)->_M_payload._M_reset(); } constexpr bool _M_is_engaged() const noexcept { return static_cast(this)->_M_payload._M_engaged; } constexpr _Tp& _M_get() noexcept { ; return static_cast<_Dp*>(this)->_M_payload._M_get(); } constexpr const _Tp& _M_get() const noexcept { ; return static_cast(this)->_M_payload._M_get(); } }; # 470 "/usr/include/c++/10/optional" 3 template, bool = is_trivially_move_constructible_v<_Tp>> struct _Optional_base : _Optional_base_impl<_Tp, _Optional_base<_Tp>> { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _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 struct _Optional_base<_Tp, false, true> : _Optional_base_impl<_Tp, _Optional_base<_Tp>> { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _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 struct _Optional_base<_Tp, true, false> : _Optional_base_impl<_Tp, _Optional_base<_Tp>> { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } constexpr _Optional_base(const _Optional_base& __other) = default; constexpr _Optional_base(_Optional_base&& __other) noexcept(is_nothrow_move_constructible_v<_Tp>) : _M_payload(__other._M_payload._M_engaged, std::move(__other._M_payload)) { } _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; _Optional_payload<_Tp> _M_payload; }; template struct _Optional_base<_Tp, true, true> : _Optional_base_impl<_Tp, _Optional_base<_Tp>> { constexpr _Optional_base() = default; template, bool> = false> constexpr explicit _Optional_base(in_place_t, _Args&&... __args) : _M_payload(in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>, bool> = false> constexpr explicit _Optional_base(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _M_payload(in_place, __il, std::forward<_Args>(__args)...) { } constexpr _Optional_base(const _Optional_base& __other) = default; constexpr _Optional_base(_Optional_base&& __other) = default; _Optional_base& operator=(const _Optional_base&) = default; _Optional_base& operator=(_Optional_base&&) = default; _Optional_payload<_Tp> _M_payload; }; template class optional; template using __converts_from_optional = __or_&>, is_constructible<_Tp, optional<_Up>&>, is_constructible<_Tp, const optional<_Up>&&>, is_constructible<_Tp, optional<_Up>&&>, is_convertible&, _Tp>, is_convertible&, _Tp>, is_convertible&&, _Tp>, is_convertible&&, _Tp>>; template using __assigns_from_optional = __or_&>, is_assignable<_Tp&, optional<_Up>&>, is_assignable<_Tp&, const optional<_Up>&&>, is_assignable<_Tp&, optional<_Up>&&>>; template class optional : private _Optional_base<_Tp>, private _Enable_copy_move< is_copy_constructible_v<_Tp>, __and_v, is_copy_assignable<_Tp>>, is_move_constructible_v<_Tp>, __and_v, is_move_assignable<_Tp>>, optional<_Tp>> { static_assert(!is_same_v, nullopt_t>); static_assert(!is_same_v, in_place_t>); static_assert(!is_reference_v<_Tp>); private: using _Base = _Optional_base<_Tp>; template using __not_self = __not_>>; template using __not_tag = __not_>>; template using _Requires = enable_if_t<__and_v<_Cond...>, bool>; public: using value_type = _Tp; constexpr optional() = default; constexpr optional(nullopt_t) noexcept { } template, __not_tag<_Up>, is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp>> = true> constexpr optional(_Up&& __t) : _Base(std::in_place, std::forward<_Up>(__t)) { } template, __not_tag<_Up>, is_constructible<_Tp, _Up&&>, __not_>> = false> explicit constexpr optional(_Up&& __t) : _Base(std::in_place, std::forward<_Up>(__t)) { } template>, is_constructible<_Tp, const _Up&>, is_convertible, __not_<__converts_from_optional<_Tp, _Up>>> = true> constexpr optional(const optional<_Up>& __t) { if (__t) emplace(*__t); } template>, is_constructible<_Tp, const _Up&>, __not_>, __not_<__converts_from_optional<_Tp, _Up>>> = false> explicit constexpr optional(const optional<_Up>& __t) { if (__t) emplace(*__t); } template >, is_constructible<_Tp, _Up&&>, is_convertible<_Up&&, _Tp>, __not_<__converts_from_optional<_Tp, _Up>>> = true> constexpr optional(optional<_Up>&& __t) { if (__t) emplace(std::move(*__t)); } template >, is_constructible<_Tp, _Up&&>, __not_>, __not_<__converts_from_optional<_Tp, _Up>>> = false> explicit constexpr optional(optional<_Up>&& __t) { if (__t) emplace(std::move(*__t)); } template> = false> explicit constexpr optional(in_place_t, _Args&&... __args) : _Base(std::in_place, std::forward<_Args>(__args)...) { } template&, _Args&&...>> = false> explicit constexpr optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args) : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { } optional& operator=(nullopt_t) noexcept { this->_M_reset(); return *this; } template enable_if_t<__and_v<__not_self<_Up>, __not_<__and_, is_same<_Tp, decay_t<_Up>>>>, is_constructible<_Tp, _Up>, is_assignable<_Tp&, _Up>>, optional&> operator=(_Up&& __u) { if (this->_M_is_engaged()) this->_M_get() = std::forward<_Up>(__u); else this->_M_construct(std::forward<_Up>(__u)); return *this; } template enable_if_t<__and_v<__not_>, is_constructible<_Tp, const _Up&>, is_assignable<_Tp&, _Up>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>>>, optional&> operator=(const optional<_Up>& __u) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = *__u; else this->_M_construct(*__u); } else { this->_M_reset(); } return *this; } template enable_if_t<__and_v<__not_>, is_constructible<_Tp, _Up>, is_assignable<_Tp&, _Up>, __not_<__converts_from_optional<_Tp, _Up>>, __not_<__assigns_from_optional<_Tp, _Up>>>, optional&> operator=(optional<_Up>&& __u) { if (__u) { if (this->_M_is_engaged()) this->_M_get() = std::move(*__u); else this->_M_construct(std::move(*__u)); } else { this->_M_reset(); } return *this; } template enable_if_t, _Tp&> emplace(_Args&&... __args) { this->_M_reset(); this->_M_construct(std::forward<_Args>(__args)...); return this->_M_get(); } template enable_if_t&, _Args&&...>, _Tp&> emplace(initializer_list<_Up> __il, _Args&&... __args) { this->_M_reset(); this->_M_construct(__il, std::forward<_Args>(__args)...); return this->_M_get(); } void swap(optional& __other) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>) { using std::swap; if (this->_M_is_engaged() && __other._M_is_engaged()) swap(this->_M_get(), __other._M_get()); else if (this->_M_is_engaged()) { __other._M_construct(std::move(this->_M_get())); this->_M_destruct(); } else if (__other._M_is_engaged()) { this->_M_construct(std::move(__other._M_get())); __other._M_destruct(); } } constexpr const _Tp* operator->() const { return std::__addressof(this->_M_get()); } constexpr _Tp* operator->() { return std::__addressof(this->_M_get()); } constexpr const _Tp& operator*() const& { return this->_M_get(); } constexpr _Tp& operator*()& { return this->_M_get(); } constexpr _Tp&& operator*()&& { return std::move(this->_M_get()); } constexpr const _Tp&& operator*() const&& { return std::move(this->_M_get()); } constexpr explicit operator bool() const noexcept { return this->_M_is_engaged(); } constexpr bool has_value() const noexcept { return this->_M_is_engaged(); } constexpr const _Tp& value() const& { return this->_M_is_engaged() ? this->_M_get() : (__throw_bad_optional_access(), this->_M_get()); } constexpr _Tp& value()& { return this->_M_is_engaged() ? this->_M_get() : (__throw_bad_optional_access(), this->_M_get()); } constexpr _Tp&& value()&& { return this->_M_is_engaged() ? std::move(this->_M_get()) : (__throw_bad_optional_access(), std::move(this->_M_get())); } constexpr const _Tp&& value() const&& { return this->_M_is_engaged() ? std::move(this->_M_get()) : (__throw_bad_optional_access(), std::move(this->_M_get())); } template constexpr _Tp value_or(_Up&& __u) const& { static_assert(is_copy_constructible_v<_Tp>); static_assert(is_convertible_v<_Up&&, _Tp>); return this->_M_is_engaged() ? this->_M_get() : static_cast<_Tp>(std::forward<_Up>(__u)); } template constexpr _Tp value_or(_Up&& __u) && { static_assert(is_move_constructible_v<_Tp>); static_assert(is_convertible_v<_Up&&, _Tp>); return this->_M_is_engaged() ? std::move(this->_M_get()) : static_cast<_Tp>(std::forward<_Up>(__u)); } void reset() noexcept { this->_M_reset(); } }; template using __optional_relop_t = enable_if_t::value, bool>; template using __optional_eq_t = __optional_relop_t< decltype(std::declval() == std::declval()) >; template using __optional_ne_t = __optional_relop_t< decltype(std::declval() != std::declval()) >; template using __optional_lt_t = __optional_relop_t< decltype(std::declval() < std::declval()) >; template using __optional_gt_t = __optional_relop_t< decltype(std::declval() > std::declval()) >; template using __optional_le_t = __optional_relop_t< decltype(std::declval() <= std::declval()) >; template using __optional_ge_t = __optional_relop_t< decltype(std::declval() >= std::declval()) >; template constexpr auto operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_eq_t<_Tp, _Up> { return static_cast(__lhs) == static_cast(__rhs) && (!__lhs || *__lhs == *__rhs); } template constexpr auto operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_ne_t<_Tp, _Up> { return static_cast(__lhs) != static_cast(__rhs) || (static_cast(__lhs) && *__lhs != *__rhs); } template constexpr auto operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_lt_t<_Tp, _Up> { return static_cast(__rhs) && (!__lhs || *__lhs < *__rhs); } template constexpr auto operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_gt_t<_Tp, _Up> { return static_cast(__lhs) && (!__rhs || *__lhs > *__rhs); } template constexpr auto operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_le_t<_Tp, _Up> { return !__lhs || (static_cast(__rhs) && *__lhs <= *__rhs); } template constexpr auto operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs) -> __optional_ge_t<_Tp, _Up> { return !__rhs || (static_cast(__lhs) && *__lhs >= *__rhs); } template _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 constexpr bool operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept { return !__lhs; } template constexpr strong_ordering operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept { return bool(__x) <=> false; } # 1140 "/usr/include/c++/10/optional" 3 template constexpr auto operator==(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_eq_t<_Tp, _Up> { return __lhs && *__lhs == __rhs; } template constexpr auto operator==(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_eq_t<_Up, _Tp> { return __rhs && __lhs == *__rhs; } template constexpr auto operator!=(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_ne_t<_Tp, _Up> { return !__lhs || *__lhs != __rhs; } template constexpr auto operator!=(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_ne_t<_Up, _Tp> { return !__rhs || __lhs != *__rhs; } template constexpr auto operator<(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_lt_t<_Tp, _Up> { return !__lhs || *__lhs < __rhs; } template constexpr auto operator<(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_lt_t<_Up, _Tp> { return __rhs && __lhs < *__rhs; } template constexpr auto operator>(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_gt_t<_Tp, _Up> { return __lhs && *__lhs > __rhs; } template constexpr auto operator>(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_gt_t<_Up, _Tp> { return !__rhs || __lhs > *__rhs; } template constexpr auto operator<=(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_le_t<_Tp, _Up> { return !__lhs || *__lhs <= __rhs; } template constexpr auto operator<=(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_le_t<_Up, _Tp> { return __rhs && __lhs <= *__rhs; } template constexpr auto operator>=(const optional<_Tp>& __lhs, const _Up& __rhs) -> __optional_ge_t<_Tp, _Up> { return __lhs && *__lhs >= __rhs; } template constexpr auto operator>=(const _Up& __lhs, const optional<_Tp>& __rhs) -> __optional_ge_t<_Up, _Tp> { return !__rhs || __lhs >= *__rhs; } template 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 inline enable_if_t && is_swappable_v<_Tp>> swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) { __lhs.swap(__rhs); } template enable_if_t && is_swappable_v<_Tp>)> swap(optional<_Tp>&, optional<_Tp>&) = delete; template constexpr optional> make_optional(_Tp&& __t) { return optional> { std::forward<_Tp>(__t) }; } template constexpr optional<_Tp> make_optional(_Args&&... __args) { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; } template constexpr optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; } template, 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(-3333); return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash; } }; template struct __optional_hash_call_base<_Tp, _Up, false> {}; template struct hash> : private __poison_hash>, public __optional_hash_call_base<_Tp> { using result_type [[__deprecated__]] = size_t; using argument_type [[__deprecated__]] = optional<_Tp>; }; template struct __is_fast_hash>> : __is_fast_hash> { }; template optional(_Tp) -> optional<_Tp>; } # 40 "/usr/include/c++/10/bits/node_handle.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class _Node_handle_common { using _AllocTraits = allocator_traits<_NodeAlloc>; public: using allocator_type = __alloc_rebind<_NodeAlloc, _Val>; allocator_type get_allocator() const noexcept { ; return allocator_type(*_M_alloc); } explicit operator bool() const noexcept { return _M_ptr != nullptr; } [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; } protected: constexpr _Node_handle_common() noexcept : _M_ptr(), _M_alloc() {} ~_Node_handle_common() { _M_destroy(); } _Node_handle_common(_Node_handle_common&& __nh) noexcept : _M_ptr(__nh._M_ptr), _M_alloc(std::move(__nh._M_alloc)) { __nh._M_ptr = nullptr; __nh._M_alloc = nullopt; } _Node_handle_common& operator=(_Node_handle_common&& __nh) noexcept { _M_destroy(); _M_ptr = __nh._M_ptr; if constexpr (is_move_assignable_v<_NodeAlloc>) { if (_AllocTraits::propagate_on_container_move_assignment::value || !this->_M_alloc) this->_M_alloc = std::move(__nh._M_alloc); else { ; } } else { ; } __nh._M_ptr = nullptr; __nh._M_alloc = nullopt; return *this; } _Node_handle_common(typename _AllocTraits::pointer __ptr, const _NodeAlloc& __alloc) : _M_ptr(__ptr), _M_alloc(__alloc) { } void _M_swap(_Node_handle_common& __nh) noexcept { using std::swap; swap(_M_ptr, __nh._M_ptr); if (_AllocTraits::propagate_on_container_swap::value || !_M_alloc || !__nh._M_alloc) _M_alloc.swap(__nh._M_alloc); else { ; } } private: void _M_destroy() noexcept { if (_M_ptr != nullptr) { allocator_type __alloc(*_M_alloc); allocator_traits::destroy(__alloc, _M_ptr->_M_valptr()); _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1); } } protected: typename _AllocTraits::pointer _M_ptr; private: optional<_NodeAlloc> _M_alloc; template friend class _Rb_tree; }; template class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc> { public: constexpr _Node_handle() noexcept = default; ~_Node_handle() = default; _Node_handle(_Node_handle&&) noexcept = default; _Node_handle& operator=(_Node_handle&&) noexcept = default; using key_type = _Key; using mapped_type = typename _Value::second_type; key_type& key() const noexcept { ; return *_M_pkey; } mapped_type& mapped() const noexcept { ; return *_M_pmapped; } void swap(_Node_handle& __nh) noexcept { this->_M_swap(__nh); using std::swap; swap(_M_pkey, __nh._M_pkey); swap(_M_pmapped, __nh._M_pmapped); } friend void swap(_Node_handle& __x, _Node_handle& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } private: using _AllocTraits = allocator_traits<_NodeAlloc>; _Node_handle(typename _AllocTraits::pointer __ptr, const _NodeAlloc& __alloc) : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { if (__ptr) { auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first); _M_pkey = _S_pointer_to(__key); _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second); } else { _M_pkey = nullptr; _M_pmapped = nullptr; } } template using __pointer = __ptr_rebind>; __pointer<_Key> _M_pkey = nullptr; __pointer _M_pmapped = nullptr; template __pointer<_Tp> _S_pointer_to(_Tp& __obj) { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); } const key_type& _M_key() const noexcept { return key(); } template friend class _Rb_tree; template friend class _Hashtable; }; template class _Node_handle<_Value, _Value, _NodeAlloc> : public _Node_handle_common<_Value, _NodeAlloc> { public: constexpr _Node_handle() noexcept = default; ~_Node_handle() = default; _Node_handle(_Node_handle&&) noexcept = default; _Node_handle& operator=(_Node_handle&&) noexcept = default; using value_type = _Value; value_type& value() const noexcept { ; return *this->_M_ptr->_M_valptr(); } void swap(_Node_handle& __nh) noexcept { this->_M_swap(__nh); } friend void swap(_Node_handle& __x, _Node_handle& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } private: using _AllocTraits = allocator_traits<_NodeAlloc>; _Node_handle(typename _AllocTraits::pointer __ptr, const _NodeAlloc& __alloc) : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { } const value_type& _M_key() const noexcept { return value(); } template friend class _Rb_tree; template friend class _Hashtable; }; template struct _Node_insert_return { _Iterator position = _Iterator(); bool inserted = false; _NodeHandle node; }; } # 38 "/usr/include/c++/10/bits/hashtable.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template using __cache_default = __not_<__and_< __is_fast_hash<_Hash>, __is_nothrow_invocable>>; # 169 "/usr/include/c++/10/bits/hashtable.h" 3 template class _Hashtable : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits>, public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>, public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>, public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>, public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>, private __detail::_Hashtable_alloc< __alloc_rebind<_Alloc, __detail::_Hash_node<_Value, _Traits::__hash_cached::value>>> { static_assert(is_same::type, _Value>::value, "unordered container must have a non-const, non-volatile value_type"); static_assert(is_same{}, "unordered container must have the same value_type as its allocator"); using __traits_type = _Traits; using __hash_cached = typename __traits_type::__hash_cached; using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>; using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>; using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>; using __value_alloc_traits = typename __hashtable_alloc::__value_alloc_traits; using __node_alloc_traits = typename __hashtable_alloc::__node_alloc_traits; using __node_base = typename __hashtable_alloc::__node_base; using __bucket_type = typename __hashtable_alloc::__bucket_type; public: typedef _Key key_type; typedef _Value value_type; typedef _Alloc allocator_type; typedef _Equal key_equal; typedef typename __value_alloc_traits::pointer pointer; typedef typename __value_alloc_traits::const_pointer const_pointer; typedef value_type& reference; typedef const value_type& const_reference; private: using __rehash_type = _RehashPolicy; using __rehash_state = typename __rehash_type::_State; using __constant_iterators = typename __traits_type::__constant_iterators; using __unique_keys = typename __traits_type::__unique_keys; using __key_extract = typename std::conditional< __constant_iterators::value, __detail::_Identity, __detail::_Select1st>::type; using __hashtable_base = __detail:: _Hashtable_base<_Key, _Value, _ExtractKey, _Equal, _H1, _H2, _Hash, _Traits>; using __hash_code_base = typename __hashtable_base::__hash_code_base; using __hash_code = typename __hashtable_base::__hash_code; using __ireturn_type = typename __hashtable_base::__ireturn_type; using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>; using __reuse_or_alloc_node_gen_t = __detail::_ReuseOrAllocNode<__node_alloc_type>; using __alloc_node_gen_t = __detail::_AllocNode<__node_alloc_type>; struct _Scoped_node { _Scoped_node(__node_type* __n, __hashtable_alloc* __h) : _M_h(__h), _M_node(__n) { } template _Scoped_node(__hashtable_alloc* __h, _Args&&... __args) : _M_h(__h), _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...)) { } ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); }; _Scoped_node(const _Scoped_node&) = delete; _Scoped_node& operator=(const _Scoped_node&) = delete; __hashtable_alloc* _M_h; __node_type* _M_node; }; template static constexpr typename conditional::value, const value_type&, value_type&&>::type __fwd_value_for(value_type& __val) noexcept { return std::move(__val); } template using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>; template using __if_hash_not_cached = __or_<__hash_cached, _Cond>; struct __hash_code_base_access : __hash_code_base { using __hash_code_base::_M_bucket_index; }; static_assert(noexcept(declval() ._M_bucket_index((const __node_type*)nullptr, (std::size_t)0)), "Cache the hash code or qualify your functors involved" " in hash code and bucket index computation with noexcept"); static_assert(__if_hash_cached>::value, "Functor used to map hash code to bucket index" " must be default constructible"); template friend struct __detail::_Map_base; template friend struct __detail::_Insert_base; template friend struct __detail::_Insert; template friend struct __detail::_Equality; public: using size_type = typename __hashtable_base::size_type; using difference_type = typename __hashtable_base::difference_type; using iterator = typename __hashtable_base::iterator; using const_iterator = typename __hashtable_base::const_iterator; using local_iterator = typename __hashtable_base::local_iterator; using const_local_iterator = typename __hashtable_base:: const_local_iterator; using node_type = _Node_handle<_Key, _Value, __node_alloc_type>; using insert_return_type = _Node_insert_return; private: __bucket_type* _M_buckets = &_M_single_bucket; size_type _M_bucket_count = 1; __node_base _M_before_begin; size_type _M_element_count = 0; _RehashPolicy _M_rehash_policy; __bucket_type _M_single_bucket = nullptr; bool _M_uses_single_bucket(__bucket_type* __bkts) const { return __builtin_expect(__bkts == &_M_single_bucket, false); } bool _M_uses_single_bucket() const { return _M_uses_single_bucket(_M_buckets); } __hashtable_alloc& _M_base_alloc() { return *this; } __bucket_type* _M_allocate_buckets(size_type __bkt_count) { if (__builtin_expect(__bkt_count == 1, false)) { _M_single_bucket = nullptr; return &_M_single_bucket; } return __hashtable_alloc::_M_allocate_buckets(__bkt_count); } void _M_deallocate_buckets(__bucket_type* __bkts, size_type __bkt_count) { if (_M_uses_single_bucket(__bkts)) return; __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count); } void _M_deallocate_buckets() { _M_deallocate_buckets(_M_buckets, _M_bucket_count); } __node_type* _M_bucket_begin(size_type __bkt) const; __node_type* _M_begin() const { return static_cast<__node_type*>(_M_before_begin._M_nxt); } template void _M_assign_elements(_Ht&&); template void _M_assign(_Ht&&, const _NodeGenerator&); void _M_move_assign(_Hashtable&&, true_type); void _M_move_assign(_Hashtable&&, false_type); void _M_reset() noexcept; _Hashtable(const _H1& __h1, const _H2& __h2, const _Hash& __h, const _Equal& __eq, const _ExtractKey& __exk, const allocator_type& __a) : __hashtable_base(__exk, __h1, __h2, __h, __eq), __hashtable_alloc(__node_alloc_type(__a)) { } public: _Hashtable() = default; _Hashtable(size_type __bkt_count_hint, const _H1&, const _H2&, const _Hash&, const _Equal&, const _ExtractKey&, const allocator_type&); template _Hashtable(_InputIterator __first, _InputIterator __last, size_type __bkt_count_hint, const _H1&, const _H2&, const _Hash&, const _Equal&, const _ExtractKey&, const allocator_type&); _Hashtable(const _Hashtable&); _Hashtable(_Hashtable&&) noexcept; _Hashtable(const _Hashtable&, const allocator_type&); _Hashtable(_Hashtable&&, const allocator_type&); explicit _Hashtable(const allocator_type& __a) : __hashtable_alloc(__node_alloc_type(__a)) { } explicit _Hashtable(size_type __bkt_count_hint, const _H1& __hf = _H1(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Hashtable(__bkt_count_hint, __hf, _H2(), _Hash(), __eql, __key_extract(), __a) { } template _Hashtable(_InputIterator __f, _InputIterator __l, size_type __bkt_count_hint = 0, const _H1& __hf = _H1(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Hashtable(__f, __l, __bkt_count_hint, __hf, _H2(), _Hash(), __eql, __key_extract(), __a) { } _Hashtable(initializer_list __l, size_type __bkt_count_hint = 0, const _H1& __hf = _H1(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint, __hf, _H2(), _Hash(), __eql, __key_extract(), __a) { } _Hashtable& operator=(const _Hashtable& __ht); _Hashtable& operator=(_Hashtable&& __ht) noexcept(__node_alloc_traits::_S_nothrow_move() && is_nothrow_move_assignable<_H1>::value && is_nothrow_move_assignable<_Equal>::value) { constexpr bool __move_storage = __node_alloc_traits::_S_propagate_on_move_assign() || __node_alloc_traits::_S_always_equal(); _M_move_assign(std::move(__ht), __bool_constant<__move_storage>()); return *this; } _Hashtable& operator=(initializer_list __l) { __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); _M_before_begin._M_nxt = nullptr; clear(); this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys()); return *this; } ~_Hashtable() noexcept; void swap(_Hashtable&) noexcept(__and_<__is_nothrow_swappable<_H1>, __is_nothrow_swappable<_Equal>>::value); iterator begin() noexcept { return iterator(_M_begin()); } const_iterator begin() const noexcept { return const_iterator(_M_begin()); } iterator end() noexcept { return iterator(nullptr); } const_iterator end() const noexcept { return const_iterator(nullptr); } const_iterator cbegin() const noexcept { return const_iterator(_M_begin()); } const_iterator cend() const noexcept { return const_iterator(nullptr); } size_type size() const noexcept { return _M_element_count; } [[__nodiscard__]] bool empty() const noexcept { return size() == 0; } allocator_type get_allocator() const noexcept { return allocator_type(this->_M_node_allocator()); } size_type max_size() const noexcept { return __node_alloc_traits::max_size(this->_M_node_allocator()); } key_equal key_eq() const { return this->_M_eq(); } size_type bucket_count() const noexcept { return _M_bucket_count; } size_type max_bucket_count() const noexcept { return max_size(); } size_type bucket_size(size_type __bkt) const { return std::distance(begin(__bkt), end(__bkt)); } size_type bucket(const key_type& __k) const { return _M_bucket_index(__k, this->_M_hash_code(__k)); } local_iterator begin(size_type __bkt) { return local_iterator(*this, _M_bucket_begin(__bkt), __bkt, _M_bucket_count); } local_iterator end(size_type __bkt) { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); } const_local_iterator begin(size_type __bkt) const { return const_local_iterator(*this, _M_bucket_begin(__bkt), __bkt, _M_bucket_count); } const_local_iterator end(size_type __bkt) const { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } const_local_iterator cbegin(size_type __bkt) const { return const_local_iterator(*this, _M_bucket_begin(__bkt), __bkt, _M_bucket_count); } const_local_iterator cend(size_type __bkt) const { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } float load_factor() const noexcept { return static_cast(size()) / static_cast(bucket_count()); } const _RehashPolicy& __rehash_policy() const { return _M_rehash_policy; } void __rehash_policy(const _RehashPolicy& __pol) { _M_rehash_policy = __pol; } iterator find(const key_type& __k); const_iterator find(const key_type& __k) const; size_type count(const key_type& __k) const; std::pair equal_range(const key_type& __k); std::pair equal_range(const key_type& __k) const; protected: size_type _M_bucket_index(__node_type* __n) const noexcept { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); } size_type _M_bucket_index(const key_type& __k, __hash_code __c) const { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); } __node_base* _M_find_before_node(size_type, const key_type&, __hash_code) const; __node_type* _M_find_node(size_type __bkt, const key_type& __key, __hash_code __c) const { __node_base* __before_n = _M_find_before_node(__bkt, __key, __c); if (__before_n) return static_cast<__node_type*>(__before_n->_M_nxt); return nullptr; } void _M_insert_bucket_begin(size_type, __node_type*); void _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n, size_type __next_bkt); __node_base* _M_get_previous_node(size_type __bkt, __node_base* __n); iterator _M_insert_unique_node(const key_type& __k, size_type __bkt, __hash_code __code, __node_type* __n, size_type __n_elt = 1); iterator _M_insert_multi_node(__node_type* __hint, const key_type& __k, __hash_code __code, __node_type* __n); template std::pair _M_emplace(true_type, _Args&&... __args); template iterator _M_emplace(false_type __uk, _Args&&... __args) { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); } template iterator _M_emplace(const_iterator, true_type __uk, _Args&&... __args) { return _M_emplace(__uk, std::forward<_Args>(__args)...).first; } template iterator _M_emplace(const_iterator, false_type, _Args&&... __args); template std::pair _M_insert(_Arg&&, const _NodeGenerator&, true_type, size_type = 1); template iterator _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, false_type __uk) { return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen, __uk); } template iterator _M_insert(const_iterator, _Arg&& __arg, const _NodeGenerator& __node_gen, true_type __uk) { return _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first; } template iterator _M_insert(const_iterator, _Arg&&, const _NodeGenerator&, false_type); size_type _M_erase(true_type, const key_type&); size_type _M_erase(false_type, const key_type&); iterator _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n); public: template __ireturn_type emplace(_Args&&... __args) { return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); } template iterator emplace_hint(const_iterator __hint, _Args&&... __args) { return _M_emplace(__hint, __unique_keys(), std::forward<_Args>(__args)...); } iterator erase(const_iterator); iterator erase(iterator __it) { return erase(const_iterator(__it)); } size_type erase(const key_type& __k) { return _M_erase(__unique_keys(), __k); } iterator erase(const_iterator, const_iterator); void clear() noexcept; void rehash(size_type __bkt_count); insert_return_type _M_reinsert_node(node_type&& __nh) { insert_return_type __ret; if (__nh.empty()) __ret.position = end(); else { ; const key_type& __k = __nh._M_key(); __hash_code __code = this->_M_hash_code(__k); size_type __bkt = _M_bucket_index(__k, __code); if (__node_type* __n = _M_find_node(__bkt, __k, __code)) { __ret.node = std::move(__nh); __ret.position = iterator(__n); __ret.inserted = false; } else { __ret.position = _M_insert_unique_node(__k, __bkt, __code, __nh._M_ptr); __nh._M_ptr = nullptr; __ret.inserted = true; } } return __ret; } iterator _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh) { if (__nh.empty()) return end(); ; const key_type& __k = __nh._M_key(); auto __code = this->_M_hash_code(__k); auto __ret = _M_insert_multi_node(__hint._M_cur, __k, __code, __nh._M_ptr); __nh._M_ptr = nullptr; return __ret; } private: node_type _M_extract_node(size_t __bkt, __node_base* __prev_n) { __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt); if (__prev_n == _M_buckets[__bkt]) _M_remove_bucket_begin(__bkt, __n->_M_next(), __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0); else if (__n->_M_nxt) { size_type __next_bkt = _M_bucket_index(__n->_M_next()); if (__next_bkt != __bkt) _M_buckets[__next_bkt] = __prev_n; } __prev_n->_M_nxt = __n->_M_nxt; __n->_M_nxt = nullptr; --_M_element_count; return { __n, this->_M_node_allocator() }; } public: node_type extract(const_iterator __pos) { size_t __bkt = _M_bucket_index(__pos._M_cur); return _M_extract_node(__bkt, _M_get_previous_node(__bkt, __pos._M_cur)); } node_type extract(const _Key& __k) { node_type __nh; __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); if (__node_base* __prev_node = _M_find_before_node(__bkt, __k, __code)) __nh = _M_extract_node(__bkt, __prev_node); return __nh; } template void _M_merge_unique(_Compatible_Hashtable& __src) noexcept { static_assert(is_same_v, "Node types are compatible"); ; auto __n_elt = __src.size(); for (auto __i = __src.begin(), __end = __src.end(); __i != __end;) { auto __pos = __i++; const key_type& __k = this->_M_extract()(*__pos); __hash_code __code = this->_M_hash_code(__k); size_type __bkt = _M_bucket_index(__k, __code); if (_M_find_node(__bkt, __k, __code) == nullptr) { auto __nh = __src.extract(__pos); _M_insert_unique_node(__k, __bkt, __code, __nh._M_ptr, __n_elt); __nh._M_ptr = nullptr; __n_elt = 1; } else if (__n_elt != 1) --__n_elt; } } template void _M_merge_multi(_Compatible_Hashtable& __src) noexcept { static_assert(is_same_v, "Node types are compatible"); ; this->reserve(size() + __src.size()); for (auto __i = __src.begin(), __end = __src.end(); __i != __end;) _M_reinsert_node_multi(cend(), __src.extract(__i++)); } private: void _M_rehash_aux(size_type __bkt_count, true_type); void _M_rehash_aux(size_type __bkt_count, false_type); void _M_rehash(size_type __bkt_count, const __rehash_state& __state); }; template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_bucket_begin(size_type __bkt) const -> __node_type* { __node_base* __n = _M_buckets[__bkt]; return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr; } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _Hashtable(size_type __bkt_count_hint, const _H1& __h1, const _H2& __h2, const _Hash& __h, const _Equal& __eq, const _ExtractKey& __exk, const allocator_type& __a) : _Hashtable(__h1, __h2, __h, __eq, __exk, __a) { auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint); if (__bkt_count > _M_bucket_count) { _M_buckets = _M_allocate_buckets(__bkt_count); _M_bucket_count = __bkt_count; } } template template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _Hashtable(_InputIterator __f, _InputIterator __l, size_type __bkt_count_hint, const _H1& __h1, const _H2& __h2, const _Hash& __h, const _Equal& __eq, const _ExtractKey& __exk, const allocator_type& __a) : _Hashtable(__h1, __h2, __h, __eq, __exk, __a) { auto __nb_elems = __detail::__distance_fw(__f, __l); auto __bkt_count = _M_rehash_policy._M_next_bkt( std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems), __bkt_count_hint)); if (__bkt_count > _M_bucket_count) { _M_buckets = _M_allocate_buckets(__bkt_count); _M_bucket_count = __bkt_count; } for (; __f != __l; ++__f) this->insert(*__f); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: operator=(const _Hashtable& __ht) -> _Hashtable& { if (&__ht == this) return *this; if (__node_alloc_traits::_S_propagate_on_copy_assign()) { auto& __this_alloc = this->_M_node_allocator(); auto& __that_alloc = __ht._M_node_allocator(); if (!__node_alloc_traits::_S_always_equal() && __this_alloc != __that_alloc) { this->_M_deallocate_nodes(_M_begin()); _M_before_begin._M_nxt = nullptr; _M_deallocate_buckets(); _M_buckets = nullptr; std::__alloc_on_copy(__this_alloc, __that_alloc); __hashtable_base::operator=(__ht); _M_bucket_count = __ht._M_bucket_count; _M_element_count = __ht._M_element_count; _M_rehash_policy = __ht._M_rehash_policy; __alloc_node_gen_t __alloc_node_gen(*this); try { _M_assign(__ht, __alloc_node_gen); } catch(...) { _M_reset(); throw; } return *this; } std::__alloc_on_copy(__this_alloc, __that_alloc); } _M_assign_elements(__ht); return *this; } template template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_assign_elements(_Ht&& __ht) { __bucket_type* __former_buckets = nullptr; std::size_t __former_bucket_count = _M_bucket_count; const __rehash_state& __former_state = _M_rehash_policy._M_state(); if (_M_bucket_count != __ht._M_bucket_count) { __former_buckets = _M_buckets; _M_buckets = _M_allocate_buckets(__ht._M_bucket_count); _M_bucket_count = __ht._M_bucket_count; } else __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type)); try { __hashtable_base::operator=(std::forward<_Ht>(__ht)); _M_element_count = __ht._M_element_count; _M_rehash_policy = __ht._M_rehash_policy; __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); _M_before_begin._M_nxt = nullptr; _M_assign(std::forward<_Ht>(__ht), __roan); if (__former_buckets) _M_deallocate_buckets(__former_buckets, __former_bucket_count); } catch(...) { if (__former_buckets) { _M_deallocate_buckets(); _M_rehash_policy._M_reset(__former_state); _M_buckets = __former_buckets; _M_bucket_count = __former_bucket_count; } __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type)); throw; } } template template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen) { __bucket_type* __buckets = nullptr; if (!_M_buckets) _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count); try { if (!__ht._M_before_begin._M_nxt) return; __node_type* __ht_n = __ht._M_begin(); __node_type* __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); this->_M_copy_code(__this_n, __ht_n); _M_before_begin._M_nxt = __this_n; _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin; __node_base* __prev_n = __this_n; for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) { __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); __prev_n->_M_nxt = __this_n; this->_M_copy_code(__this_n, __ht_n); size_type __bkt = _M_bucket_index(__this_n); if (!_M_buckets[__bkt]) _M_buckets[__bkt] = __prev_n; __prev_n = __this_n; } } catch(...) { clear(); if (__buckets) _M_deallocate_buckets(); throw; } } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_reset() noexcept { _M_rehash_policy._M_reset(); _M_bucket_count = 1; _M_single_bucket = nullptr; _M_buckets = &_M_single_bucket; _M_before_begin._M_nxt = nullptr; _M_element_count = 0; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_move_assign(_Hashtable&& __ht, true_type) { this->_M_deallocate_nodes(_M_begin()); _M_deallocate_buckets(); __hashtable_base::operator=(std::move(__ht)); _M_rehash_policy = __ht._M_rehash_policy; if (!__ht._M_uses_single_bucket()) _M_buckets = __ht._M_buckets; else { _M_buckets = &_M_single_bucket; _M_single_bucket = __ht._M_single_bucket; } _M_bucket_count = __ht._M_bucket_count; _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; _M_element_count = __ht._M_element_count; std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator()); if (_M_begin()) _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; __ht._M_reset(); } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_move_assign(_Hashtable&& __ht, false_type) { if (__ht._M_node_allocator() == this->_M_node_allocator()) _M_move_assign(std::move(__ht), true_type()); else { _M_assign_elements(std::move(__ht)); __ht.clear(); } } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _Hashtable(const _Hashtable& __ht) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc( __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())), _M_buckets(nullptr), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { __alloc_node_gen_t __alloc_node_gen(*this); _M_assign(__ht, __alloc_node_gen); } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _Hashtable(_Hashtable&& __ht) noexcept : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc(std::move(__ht._M_base_alloc())), _M_buckets(__ht._M_buckets), _M_bucket_count(__ht._M_bucket_count), _M_before_begin(__ht._M_before_begin._M_nxt), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { if (__ht._M_uses_single_bucket()) { _M_buckets = &_M_single_bucket; _M_single_bucket = __ht._M_single_bucket; } if (_M_begin()) _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; __ht._M_reset(); } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _Hashtable(const _Hashtable& __ht, const allocator_type& __a) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc(__node_alloc_type(__a)), _M_buckets(), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { __alloc_node_gen_t __alloc_node_gen(*this); _M_assign(__ht, __alloc_node_gen); } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _Hashtable(_Hashtable&& __ht, const allocator_type& __a) : __hashtable_base(__ht), __map_base(__ht), __rehash_base(__ht), __hashtable_alloc(__node_alloc_type(__a)), _M_buckets(nullptr), _M_bucket_count(__ht._M_bucket_count), _M_element_count(__ht._M_element_count), _M_rehash_policy(__ht._M_rehash_policy) { if (__ht._M_node_allocator() == this->_M_node_allocator()) { if (__ht._M_uses_single_bucket()) { _M_buckets = &_M_single_bucket; _M_single_bucket = __ht._M_single_bucket; } else _M_buckets = __ht._M_buckets; _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; if (_M_begin()) _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; __ht._M_reset(); } else { __alloc_node_gen_t __alloc_gen(*this); using _Fwd_Ht = typename conditional<__move_if_noexcept_cond::value, const _Hashtable&, _Hashtable&&>::type; _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen); __ht.clear(); } } template _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: ~_Hashtable() noexcept { clear(); _M_deallocate_buckets(); } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: swap(_Hashtable& __x) noexcept(__and_<__is_nothrow_swappable<_H1>, __is_nothrow_swappable<_Equal>>::value) { this->_M_swap(__x); std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator()); std::swap(_M_rehash_policy, __x._M_rehash_policy); if (this->_M_uses_single_bucket()) { if (!__x._M_uses_single_bucket()) { _M_buckets = __x._M_buckets; __x._M_buckets = &__x._M_single_bucket; } } else if (__x._M_uses_single_bucket()) { __x._M_buckets = _M_buckets; _M_buckets = &_M_single_bucket; } else std::swap(_M_buckets, __x._M_buckets); std::swap(_M_bucket_count, __x._M_bucket_count); std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt); std::swap(_M_element_count, __x._M_element_count); std::swap(_M_single_bucket, __x._M_single_bucket); if (_M_begin()) _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; if (__x._M_begin()) __x._M_buckets[__x._M_bucket_index(__x._M_begin())] = &__x._M_before_begin; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: find(const key_type& __k) -> iterator { __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); __node_type* __p = _M_find_node(__bkt, __k, __code); return __p ? iterator(__p) : end(); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: find(const key_type& __k) const -> const_iterator { __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); __node_type* __p = _M_find_node(__bkt, __k, __code); return __p ? const_iterator(__p) : end(); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: count(const key_type& __k) const -> size_type { __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); __node_type* __p = _M_bucket_begin(__bkt); if (!__p) return 0; std::size_t __result = 0; for (;; __p = __p->_M_next()) { if (this->_M_equals(__k, __code, __p)) ++__result; else if (__result) break; if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt) break; } return __result; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: equal_range(const key_type& __k) -> pair { __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); __node_type* __p = _M_find_node(__bkt, __k, __code); if (__p) { __node_type* __p1 = __p->_M_next(); while (__p1 && _M_bucket_index(__p1) == __bkt && this->_M_equals(__k, __code, __p1)) __p1 = __p1->_M_next(); return std::make_pair(iterator(__p), iterator(__p1)); } else return std::make_pair(end(), end()); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: equal_range(const key_type& __k) const -> pair { __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); __node_type* __p = _M_find_node(__bkt, __k, __code); if (__p) { __node_type* __p1 = __p->_M_next(); while (__p1 && _M_bucket_index(__p1) == __bkt && this->_M_equals(__k, __code, __p1)) __p1 = __p1->_M_next(); return std::make_pair(const_iterator(__p), const_iterator(__p1)); } else return std::make_pair(end(), end()); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_find_before_node(size_type __bkt, const key_type& __k, __hash_code __code) const -> __node_base* { __node_base* __prev_p = _M_buckets[__bkt]; if (!__prev_p) return nullptr; for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);; __p = __p->_M_next()) { if (this->_M_equals(__k, __code, __p)) return __prev_p; if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt) break; __prev_p = __p; } return nullptr; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_insert_bucket_begin(size_type __bkt, __node_type* __node) { if (_M_buckets[__bkt]) { __node->_M_nxt = _M_buckets[__bkt]->_M_nxt; _M_buckets[__bkt]->_M_nxt = __node; } else { __node->_M_nxt = _M_before_begin._M_nxt; _M_before_begin._M_nxt = __node; if (__node->_M_nxt) _M_buckets[_M_bucket_index(__node->_M_next())] = __node; _M_buckets[__bkt] = &_M_before_begin; } } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_remove_bucket_begin(size_type __bkt, __node_type* __next, size_type __next_bkt) { if (!__next || __next_bkt != __bkt) { if (__next) _M_buckets[__next_bkt] = _M_buckets[__bkt]; if (&_M_before_begin == _M_buckets[__bkt]) _M_before_begin._M_nxt = __next; _M_buckets[__bkt] = nullptr; } } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_get_previous_node(size_type __bkt, __node_base* __n) -> __node_base* { __node_base* __prev_n = _M_buckets[__bkt]; while (__prev_n->_M_nxt != __n) __prev_n = __prev_n->_M_nxt; return __prev_n; } template template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_emplace(true_type, _Args&&... __args) -> pair { _Scoped_node __node { this, std::forward<_Args>(__args)... }; const key_type& __k = this->_M_extract()(__node._M_node->_M_v()); __hash_code __code = this->_M_hash_code(__k); size_type __bkt = _M_bucket_index(__k, __code); if (__node_type* __p = _M_find_node(__bkt, __k, __code)) return std::make_pair(iterator(__p), false); auto __pos = _M_insert_unique_node(__k, __bkt, __code, __node._M_node); __node._M_node = nullptr; return { __pos, true }; } template template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_emplace(const_iterator __hint, false_type, _Args&&... __args) -> iterator { _Scoped_node __node { this, std::forward<_Args>(__args)... }; const key_type& __k = this->_M_extract()(__node._M_node->_M_v()); __hash_code __code = this->_M_hash_code(__k); auto __pos = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node); __node._M_node = nullptr; return __pos; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_insert_unique_node(const key_type& __k, size_type __bkt, __hash_code __code, __node_type* __node, size_type __n_elt) -> iterator { const __rehash_state& __saved_state = _M_rehash_policy._M_state(); std::pair __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, __n_elt); if (__do_rehash.first) { _M_rehash(__do_rehash.second, __saved_state); __bkt = _M_bucket_index(__k, __code); } this->_M_store_code(__node, __code); _M_insert_bucket_begin(__bkt, __node); ++_M_element_count; return iterator(__node); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_insert_multi_node(__node_type* __hint, const key_type& __k, __hash_code __code, __node_type* __node) -> iterator { const __rehash_state& __saved_state = _M_rehash_policy._M_state(); std::pair __do_rehash = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); if (__do_rehash.first) _M_rehash(__do_rehash.second, __saved_state); this->_M_store_code(__node, __code); size_type __bkt = _M_bucket_index(__k, __code); __node_base* __prev = __builtin_expect(__hint != nullptr, false) && this->_M_equals(__k, __code, __hint) ? __hint : _M_find_before_node(__bkt, __k, __code); if (__prev) { __node->_M_nxt = __prev->_M_nxt; __prev->_M_nxt = __node; if (__builtin_expect(__prev == __hint, false)) if (__node->_M_nxt && !this->_M_equals(__k, __code, __node->_M_next())) { size_type __next_bkt = _M_bucket_index(__node->_M_next()); if (__next_bkt != __bkt) _M_buckets[__next_bkt] = __node; } } else _M_insert_bucket_begin(__bkt, __node); ++_M_element_count; return iterator(__node); } template template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, true_type, size_type __n_elt) -> pair { const key_type& __k = this->_M_extract()(__v); __hash_code __code = this->_M_hash_code(__k); size_type __bkt = _M_bucket_index(__k, __code); if (__node_type* __node = _M_find_node(__bkt, __k, __code)) return { iterator(__node), false }; _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this }; auto __pos = _M_insert_unique_node(__k, __bkt, __code, __node._M_node, __n_elt); __node._M_node = nullptr; return { __pos, true }; } template template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_insert(const_iterator __hint, _Arg&& __v, const _NodeGenerator& __node_gen, false_type) -> iterator { __hash_code __code = this->_M_hash_code(this->_M_extract()(__v)); _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this }; const key_type& __k = this->_M_extract()(__node._M_node->_M_v()); auto __pos = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node); __node._M_node = nullptr; return __pos; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: erase(const_iterator __it) -> iterator { __node_type* __n = __it._M_cur; std::size_t __bkt = _M_bucket_index(__n); __node_base* __prev_n = _M_get_previous_node(__bkt, __n); return _M_erase(__bkt, __prev_n, __n); } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n) -> iterator { if (__prev_n == _M_buckets[__bkt]) _M_remove_bucket_begin(__bkt, __n->_M_next(), __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0); else if (__n->_M_nxt) { size_type __next_bkt = _M_bucket_index(__n->_M_next()); if (__next_bkt != __bkt) _M_buckets[__next_bkt] = __prev_n; } __prev_n->_M_nxt = __n->_M_nxt; iterator __result(__n->_M_next()); this->_M_deallocate_node(__n); --_M_element_count; return __result; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_erase(true_type, const key_type& __k) -> size_type { __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code); if (!__prev_n) return 0; __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt); _M_erase(__bkt, __prev_n, __n); return 1; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_erase(false_type, const key_type& __k) -> size_type { __hash_code __code = this->_M_hash_code(__k); std::size_t __bkt = _M_bucket_index(__k, __code); __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code); if (!__prev_n) return 0; __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt); __node_type* __n_last = __n; std::size_t __n_last_bkt = __bkt; do { __n_last = __n_last->_M_next(); if (!__n_last) break; __n_last_bkt = _M_bucket_index(__n_last); } while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last)); size_type __result = 0; do { __node_type* __p = __n->_M_next(); this->_M_deallocate_node(__n); __n = __p; ++__result; --_M_element_count; } while (__n != __n_last); if (__prev_n == _M_buckets[__bkt]) _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); else if (__n_last && __n_last_bkt != __bkt) _M_buckets[__n_last_bkt] = __prev_n; __prev_n->_M_nxt = __n_last; return __result; } template auto _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: erase(const_iterator __first, const_iterator __last) -> iterator { __node_type* __n = __first._M_cur; __node_type* __last_n = __last._M_cur; if (__n == __last_n) return iterator(__n); std::size_t __bkt = _M_bucket_index(__n); __node_base* __prev_n = _M_get_previous_node(__bkt, __n); bool __is_bucket_begin = __n == _M_bucket_begin(__bkt); std::size_t __n_bkt = __bkt; for (;;) { do { __node_type* __tmp = __n; __n = __n->_M_next(); this->_M_deallocate_node(__tmp); --_M_element_count; if (!__n) break; __n_bkt = _M_bucket_index(__n); } while (__n != __last_n && __n_bkt == __bkt); if (__is_bucket_begin) _M_remove_bucket_begin(__bkt, __n, __n_bkt); if (__n == __last_n) break; __is_bucket_begin = true; __bkt = __n_bkt; } if (__n && (__n_bkt != __bkt || __is_bucket_begin)) _M_buckets[__n_bkt] = __prev_n; __prev_n->_M_nxt = __n; return iterator(__n); } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: clear() noexcept { this->_M_deallocate_nodes(_M_begin()); __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type)); _M_element_count = 0; _M_before_begin._M_nxt = nullptr; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: rehash(size_type __bkt_count) { const __rehash_state& __saved_state = _M_rehash_policy._M_state(); __bkt_count = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), __bkt_count); __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count); if (__bkt_count != _M_bucket_count) _M_rehash(__bkt_count, __saved_state); else _M_rehash_policy._M_reset(__saved_state); } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_rehash(size_type __bkt_count, const __rehash_state& __state) { try { _M_rehash_aux(__bkt_count, __unique_keys()); } catch(...) { _M_rehash_policy._M_reset(__state); throw; } } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_rehash_aux(size_type __bkt_count, true_type) { __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count); __node_type* __p = _M_begin(); _M_before_begin._M_nxt = nullptr; std::size_t __bbegin_bkt = 0; while (__p) { __node_type* __next = __p->_M_next(); std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __bkt_count); if (!__new_buckets[__bkt]) { __p->_M_nxt = _M_before_begin._M_nxt; _M_before_begin._M_nxt = __p; __new_buckets[__bkt] = &_M_before_begin; if (__p->_M_nxt) __new_buckets[__bbegin_bkt] = __p; __bbegin_bkt = __bkt; } else { __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; __new_buckets[__bkt]->_M_nxt = __p; } __p = __next; } _M_deallocate_buckets(); _M_bucket_count = __bkt_count; _M_buckets = __new_buckets; } template void _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, _RehashPolicy, _Traits>:: _M_rehash_aux(size_type __bkt_count, false_type) { __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count); __node_type* __p = _M_begin(); _M_before_begin._M_nxt = nullptr; std::size_t __bbegin_bkt = 0; std::size_t __prev_bkt = 0; __node_type* __prev_p = nullptr; bool __check_bucket = false; while (__p) { __node_type* __next = __p->_M_next(); std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __bkt_count); if (__prev_p && __prev_bkt == __bkt) { __p->_M_nxt = __prev_p->_M_nxt; __prev_p->_M_nxt = __p; __check_bucket = true; } else { if (__check_bucket) { if (__prev_p->_M_nxt) { std::size_t __next_bkt = __hash_code_base::_M_bucket_index(__prev_p->_M_next(), __bkt_count); if (__next_bkt != __prev_bkt) __new_buckets[__next_bkt] = __prev_p; } __check_bucket = false; } if (!__new_buckets[__bkt]) { __p->_M_nxt = _M_before_begin._M_nxt; _M_before_begin._M_nxt = __p; __new_buckets[__bkt] = &_M_before_begin; if (__p->_M_nxt) __new_buckets[__bbegin_bkt] = __p; __bbegin_bkt = __bkt; } else { __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; __new_buckets[__bkt]->_M_nxt = __p; } } __prev_p = __p; __prev_bkt = __bkt; __p = __next; } if (__check_bucket && __prev_p->_M_nxt) { std::size_t __next_bkt = __hash_code_base::_M_bucket_index(__prev_p->_M_next(), __bkt_count); if (__next_bkt != __prev_bkt) __new_buckets[__next_bkt] = __prev_p; } _M_deallocate_buckets(); _M_bucket_count = __bkt_count; _M_buckets = __new_buckets; } template class _Hash_merge_helper { }; template using _RequireNotAllocatorOrIntegral = __enable_if_t, __is_allocator<_Hash>>::value>; } # 47 "/usr/include/c++/10/unordered_map" 2 3 # 1 "/usr/include/c++/10/bits/unordered_map.h" 1 3 # 33 "/usr/include/c++/10/bits/unordered_map.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>; template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator >, typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>> using __umap_hashtable = _Hashtable<_Key, std::pair, _Alloc, __detail::_Select1st, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr>; template using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>; template, typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator >, typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>> using __ummap_hashtable = _Hashtable<_Key, std::pair, _Alloc, __detail::_Select1st, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr>; template class unordered_multimap; # 98 "/usr/include/c++/10/bits/unordered_map.h" 3 template, typename _Pred = equal_to<_Key>, typename _Alloc = allocator>> class unordered_map { typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; _Hashtable _M_h; public: typedef typename _Hashtable::key_type key_type; typedef typename _Hashtable::value_type value_type; typedef typename _Hashtable::mapped_type mapped_type; typedef typename _Hashtable::hasher hasher; typedef typename _Hashtable::key_equal key_equal; typedef typename _Hashtable::allocator_type allocator_type; typedef typename _Hashtable::pointer pointer; typedef typename _Hashtable::const_pointer const_pointer; typedef typename _Hashtable::reference reference; typedef typename _Hashtable::const_reference const_reference; typedef typename _Hashtable::iterator iterator; typedef typename _Hashtable::const_iterator const_iterator; typedef typename _Hashtable::local_iterator local_iterator; typedef typename _Hashtable::const_local_iterator const_local_iterator; typedef typename _Hashtable::size_type size_type; typedef typename _Hashtable::difference_type difference_type; using node_type = typename _Hashtable::node_type; using insert_return_type = typename _Hashtable::insert_return_type; unordered_map() = default; # 150 "/usr/include/c++/10/bits/unordered_map.h" 3 explicit unordered_map(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__n, __hf, __eql, __a) { } # 171 "/usr/include/c++/10/bits/unordered_map.h" 3 template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__first, __last, __n, __hf, __eql, __a) { } unordered_map(const unordered_map&) = default; unordered_map(unordered_map&&) = default; explicit unordered_map(const allocator_type& __a) : _M_h(__a) { } unordered_map(const unordered_map& __umap, const allocator_type& __a) : _M_h(__umap._M_h, __a) { } unordered_map(unordered_map&& __umap, const allocator_type& __a) : _M_h(std::move(__umap._M_h), __a) { } # 226 "/usr/include/c++/10/bits/unordered_map.h" 3 unordered_map(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__l, __n, __hf, __eql, __a) { } unordered_map(size_type __n, const allocator_type& __a) : unordered_map(__n, hasher(), key_equal(), __a) { } unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__n, __hf, key_equal(), __a) { } template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__first, __last, __n, __hf, key_equal(), __a) { } unordered_map(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_map(__l, __n, hasher(), key_equal(), __a) { } unordered_map(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_map(__l, __n, __hf, key_equal(), __a) { } unordered_map& operator=(const unordered_map&) = default; unordered_map& operator=(unordered_map&&) = default; # 288 "/usr/include/c++/10/bits/unordered_map.h" 3 unordered_map& operator=(initializer_list __l) { _M_h = __l; return *this; } allocator_type get_allocator() const noexcept { return _M_h.get_allocator(); } [[__nodiscard__]] bool empty() const noexcept { return _M_h.empty(); } size_type size() const noexcept { return _M_h.size(); } size_type max_size() const noexcept { return _M_h.max_size(); } iterator begin() noexcept { return _M_h.begin(); } const_iterator begin() const noexcept { return _M_h.begin(); } const_iterator cbegin() const noexcept { return _M_h.begin(); } iterator end() noexcept { return _M_h.end(); } const_iterator end() const noexcept { return _M_h.end(); } const_iterator cend() const noexcept { return _M_h.end(); } # 385 "/usr/include/c++/10/bits/unordered_map.h" 3 template std::pair emplace(_Args&&... __args) { return _M_h.emplace(std::forward<_Args>(__args)...); } # 416 "/usr/include/c++/10/bits/unordered_map.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } node_type extract(const_iterator __pos) { ; return _M_h.extract(__pos); } node_type extract(const key_type& __key) { return _M_h.extract(__key); } insert_return_type insert(node_type&& __nh) { return _M_h._M_reinsert_node(std::move(__nh)); } iterator insert(const_iterator, node_type&& __nh) { return _M_h._M_reinsert_node(std::move(__nh)).position; } # 468 "/usr/include/c++/10/bits/unordered_map.h" 3 template pair try_emplace(const key_type& __k, _Args&&... __args) { iterator __i = find(__k); if (__i == end()) { __i = emplace(std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple( std::forward<_Args>(__args)...)) .first; return {__i, true}; } return {__i, false}; } template pair try_emplace(key_type&& __k, _Args&&... __args) { iterator __i = find(__k); if (__i == end()) { __i = emplace(std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple( std::forward<_Args>(__args)...)) .first; return {__i, true}; } return {__i, false}; } # 531 "/usr/include/c++/10/bits/unordered_map.h" 3 template iterator try_emplace(const_iterator __hint, const key_type& __k, _Args&&... __args) { iterator __i = find(__k); if (__i == end()) __i = emplace_hint(__hint, std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple( std::forward<_Args>(__args)...)); return __i; } template iterator try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args) { iterator __i = find(__k); if (__i == end()) __i = emplace_hint(__hint, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple( std::forward<_Args>(__args)...)); return __i; } # 578 "/usr/include/c++/10/bits/unordered_map.h" 3 std::pair insert(const value_type& __x) { return _M_h.insert(__x); } std::pair insert(value_type&& __x) { return _M_h.insert(std::move(__x)); } template __enable_if_t::value, pair> insert(_Pair&& __x) { return _M_h.emplace(std::forward<_Pair>(__x)); } # 617 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator insert(const_iterator __hint, const value_type& __x) { return _M_h.insert(__hint, __x); } iterator insert(const_iterator __hint, value_type&& __x) { return _M_h.insert(__hint, std::move(__x)); } template __enable_if_t::value, iterator> insert(const_iterator __hint, _Pair&& __x) { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } # 642 "/usr/include/c++/10/bits/unordered_map.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_h.insert(__first, __last); } # 654 "/usr/include/c++/10/bits/unordered_map.h" 3 void insert(initializer_list __l) { _M_h.insert(__l); } # 680 "/usr/include/c++/10/bits/unordered_map.h" 3 template pair insert_or_assign(const key_type& __k, _Obj&& __obj) { iterator __i = find(__k); if (__i == end()) { __i = emplace(std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple(std::forward<_Obj>(__obj))) .first; return {__i, true}; } (*__i).second = std::forward<_Obj>(__obj); return {__i, false}; } template pair insert_or_assign(key_type&& __k, _Obj&& __obj) { iterator __i = find(__k); if (__i == end()) { __i = emplace(std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple(std::forward<_Obj>(__obj))) .first; return {__i, true}; } (*__i).second = std::forward<_Obj>(__obj); return {__i, false}; } # 741 "/usr/include/c++/10/bits/unordered_map.h" 3 template iterator insert_or_assign(const_iterator __hint, const key_type& __k, _Obj&& __obj) { iterator __i = find(__k); if (__i == end()) { return emplace_hint(__hint, std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple( std::forward<_Obj>(__obj))); } (*__i).second = std::forward<_Obj>(__obj); return __i; } template iterator insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj) { iterator __i = find(__k); if (__i == end()) { return emplace_hint(__hint, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple( std::forward<_Obj>(__obj))); } (*__i).second = std::forward<_Obj>(__obj); return __i; } # 790 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator erase(const_iterator __position) { return _M_h.erase(__position); } iterator erase(iterator __position) { return _M_h.erase(__position); } # 812 "/usr/include/c++/10/bits/unordered_map.h" 3 size_type erase(const key_type& __x) { return _M_h.erase(__x); } # 830 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_h.erase(__first, __last); } void clear() noexcept { _M_h.clear(); } # 854 "/usr/include/c++/10/bits/unordered_map.h" 3 void swap(unordered_map& __x) noexcept( noexcept(_M_h.swap(__x._M_h)) ) { _M_h.swap(__x._M_h); } template friend class std::_Hash_merge_helper; template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { merge(__source); } template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { merge(__source); } hasher hash_function() const { return _M_h.hash_function(); } key_equal key_eq() const { return _M_h.key_eq(); } # 918 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator find(const key_type& __x) { return _M_h.find(__x); } const_iterator find(const key_type& __x) const { return _M_h.find(__x); } # 936 "/usr/include/c++/10/bits/unordered_map.h" 3 size_type count(const key_type& __x) const { return _M_h.count(__x); } bool contains(const key_type& __x) const { return _M_h.find(__x) != _M_h.end(); } # 960 "/usr/include/c++/10/bits/unordered_map.h" 3 std::pair equal_range(const key_type& __x) { return _M_h.equal_range(__x); } std::pair equal_range(const key_type& __x) const { return _M_h.equal_range(__x); } # 982 "/usr/include/c++/10/bits/unordered_map.h" 3 mapped_type& operator[](const key_type& __k) { return _M_h[__k]; } mapped_type& operator[](key_type&& __k) { return _M_h[std::move(__k)]; } # 999 "/usr/include/c++/10/bits/unordered_map.h" 3 mapped_type& at(const key_type& __k) { return _M_h.at(__k); } const mapped_type& at(const key_type& __k) const { return _M_h.at(__k); } size_type bucket_count() const noexcept { return _M_h.bucket_count(); } size_type max_bucket_count() const noexcept { return _M_h.max_bucket_count(); } size_type bucket_size(size_type __n) const { return _M_h.bucket_size(__n); } size_type bucket(const key_type& __key) const { return _M_h.bucket(__key); } local_iterator begin(size_type __n) { return _M_h.begin(__n); } # 1055 "/usr/include/c++/10/bits/unordered_map.h" 3 const_local_iterator begin(size_type __n) const { return _M_h.begin(__n); } const_local_iterator cbegin(size_type __n) const { return _M_h.cbegin(__n); } # 1070 "/usr/include/c++/10/bits/unordered_map.h" 3 local_iterator end(size_type __n) { return _M_h.end(__n); } # 1081 "/usr/include/c++/10/bits/unordered_map.h" 3 const_local_iterator end(size_type __n) const { return _M_h.end(__n); } const_local_iterator cend(size_type __n) const { return _M_h.cend(__n); } float load_factor() const noexcept { return _M_h.load_factor(); } float max_load_factor() const noexcept { return _M_h.max_load_factor(); } void max_load_factor(float __z) { _M_h.max_load_factor(__z); } # 1118 "/usr/include/c++/10/bits/unordered_map.h" 3 void rehash(size_type __n) { _M_h.rehash(__n); } # 1129 "/usr/include/c++/10/bits/unordered_map.h" 3 void reserve(size_type __n) { _M_h.reserve(__n); } template friend bool operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); }; template>, typename _Pred = equal_to<__iter_key_t<_InputIterator>>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, typename unordered_map::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, _Pred, _Allocator>; template, typename _Pred = equal_to<_Key>, typename _Allocator = allocator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_map(initializer_list>, typename unordered_map::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, typename unordered_map::size_type, _Allocator) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, _Allocator) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireAllocator<_Allocator>> unordered_map(_InputIterator, _InputIterator, typename unordered_map::size_type, _Hash, _Allocator) -> unordered_map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template> unordered_map(initializer_list>, typename unordered_map::size_type, _Allocator) -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template> unordered_map(initializer_list>, _Allocator) -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_map(initializer_list>, typename unordered_map::size_type, _Hash, _Allocator) -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; # 1245 "/usr/include/c++/10/bits/unordered_map.h" 3 template, typename _Pred = equal_to<_Key>, typename _Alloc = allocator>> class unordered_multimap { typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; _Hashtable _M_h; public: typedef typename _Hashtable::key_type key_type; typedef typename _Hashtable::value_type value_type; typedef typename _Hashtable::mapped_type mapped_type; typedef typename _Hashtable::hasher hasher; typedef typename _Hashtable::key_equal key_equal; typedef typename _Hashtable::allocator_type allocator_type; typedef typename _Hashtable::pointer pointer; typedef typename _Hashtable::const_pointer const_pointer; typedef typename _Hashtable::reference reference; typedef typename _Hashtable::const_reference const_reference; typedef typename _Hashtable::iterator iterator; typedef typename _Hashtable::const_iterator const_iterator; typedef typename _Hashtable::local_iterator local_iterator; typedef typename _Hashtable::const_local_iterator const_local_iterator; typedef typename _Hashtable::size_type size_type; typedef typename _Hashtable::difference_type difference_type; using node_type = typename _Hashtable::node_type; unordered_multimap() = default; # 1296 "/usr/include/c++/10/bits/unordered_map.h" 3 explicit unordered_multimap(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__n, __hf, __eql, __a) { } # 1317 "/usr/include/c++/10/bits/unordered_map.h" 3 template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__first, __last, __n, __hf, __eql, __a) { } unordered_multimap(const unordered_multimap&) = default; unordered_multimap(unordered_multimap&&) = default; explicit unordered_multimap(const allocator_type& __a) : _M_h(__a) { } unordered_multimap(const unordered_multimap& __ummap, const allocator_type& __a) : _M_h(__ummap._M_h, __a) { } unordered_multimap(unordered_multimap&& __ummap, const allocator_type& __a) : _M_h(std::move(__ummap._M_h), __a) { } # 1372 "/usr/include/c++/10/bits/unordered_map.h" 3 unordered_multimap(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__l, __n, __hf, __eql, __a) { } unordered_multimap(size_type __n, const allocator_type& __a) : unordered_multimap(__n, hasher(), key_equal(), __a) { } unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__n, __hf, key_equal(), __a) { } template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) { } unordered_multimap(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_multimap(__l, __n, hasher(), key_equal(), __a) { } unordered_multimap(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multimap(__l, __n, __hf, key_equal(), __a) { } unordered_multimap& operator=(const unordered_multimap&) = default; unordered_multimap& operator=(unordered_multimap&&) = default; # 1434 "/usr/include/c++/10/bits/unordered_map.h" 3 unordered_multimap& operator=(initializer_list __l) { _M_h = __l; return *this; } allocator_type get_allocator() const noexcept { return _M_h.get_allocator(); } [[__nodiscard__]] bool empty() const noexcept { return _M_h.empty(); } size_type size() const noexcept { return _M_h.size(); } size_type max_size() const noexcept { return _M_h.max_size(); } iterator begin() noexcept { return _M_h.begin(); } const_iterator begin() const noexcept { return _M_h.begin(); } const_iterator cbegin() const noexcept { return _M_h.begin(); } iterator end() noexcept { return _M_h.end(); } const_iterator end() const noexcept { return _M_h.end(); } const_iterator cend() const noexcept { return _M_h.end(); } # 1526 "/usr/include/c++/10/bits/unordered_map.h" 3 template iterator emplace(_Args&&... __args) { return _M_h.emplace(std::forward<_Args>(__args)...); } # 1553 "/usr/include/c++/10/bits/unordered_map.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } # 1568 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator insert(const value_type& __x) { return _M_h.insert(__x); } iterator insert(value_type&& __x) { return _M_h.insert(std::move(__x)); } template __enable_if_t::value, iterator> insert(_Pair&& __x) { return _M_h.emplace(std::forward<_Pair>(__x)); } # 1602 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator insert(const_iterator __hint, const value_type& __x) { return _M_h.insert(__hint, __x); } iterator insert(const_iterator __hint, value_type&& __x) { return _M_h.insert(__hint, std::move(__x)); } template __enable_if_t::value, iterator> insert(const_iterator __hint, _Pair&& __x) { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } # 1627 "/usr/include/c++/10/bits/unordered_map.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_h.insert(__first, __last); } # 1640 "/usr/include/c++/10/bits/unordered_map.h" 3 void insert(initializer_list __l) { _M_h.insert(__l); } node_type extract(const_iterator __pos) { ; return _M_h.extract(__pos); } node_type extract(const key_type& __key) { return _M_h.extract(__key); } iterator insert(node_type&& __nh) { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); } iterator insert(const_iterator __hint, node_type&& __nh) { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); } # 1683 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator erase(const_iterator __position) { return _M_h.erase(__position); } iterator erase(iterator __position) { return _M_h.erase(__position); } # 1704 "/usr/include/c++/10/bits/unordered_map.h" 3 size_type erase(const key_type& __x) { return _M_h.erase(__x); } # 1723 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_h.erase(__first, __last); } void clear() noexcept { _M_h.clear(); } # 1747 "/usr/include/c++/10/bits/unordered_map.h" 3 void swap(unordered_multimap& __x) noexcept( noexcept(_M_h.swap(__x._M_h)) ) { _M_h.swap(__x._M_h); } template friend class std::_Hash_merge_helper; template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { merge(__source); } template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) { merge(__source); } hasher hash_function() const { return _M_h.hash_function(); } key_equal key_eq() const { return _M_h.key_eq(); } # 1813 "/usr/include/c++/10/bits/unordered_map.h" 3 iterator find(const key_type& __x) { return _M_h.find(__x); } const_iterator find(const key_type& __x) const { return _M_h.find(__x); } size_type count(const key_type& __x) const { return _M_h.count(__x); } bool contains(const key_type& __x) const { return _M_h.find(__x) != _M_h.end(); } # 1849 "/usr/include/c++/10/bits/unordered_map.h" 3 std::pair equal_range(const key_type& __x) { return _M_h.equal_range(__x); } std::pair equal_range(const key_type& __x) const { return _M_h.equal_range(__x); } size_type bucket_count() const noexcept { return _M_h.bucket_count(); } size_type max_bucket_count() const noexcept { return _M_h.max_bucket_count(); } size_type bucket_size(size_type __n) const { return _M_h.bucket_size(__n); } size_type bucket(const key_type& __key) const { return _M_h.bucket(__key); } local_iterator begin(size_type __n) { return _M_h.begin(__n); } # 1905 "/usr/include/c++/10/bits/unordered_map.h" 3 const_local_iterator begin(size_type __n) const { return _M_h.begin(__n); } const_local_iterator cbegin(size_type __n) const { return _M_h.cbegin(__n); } # 1920 "/usr/include/c++/10/bits/unordered_map.h" 3 local_iterator end(size_type __n) { return _M_h.end(__n); } # 1931 "/usr/include/c++/10/bits/unordered_map.h" 3 const_local_iterator end(size_type __n) const { return _M_h.end(__n); } const_local_iterator cend(size_type __n) const { return _M_h.cend(__n); } float load_factor() const noexcept { return _M_h.load_factor(); } float max_load_factor() const noexcept { return _M_h.max_load_factor(); } void max_load_factor(float __z) { _M_h.max_load_factor(__z); } # 1968 "/usr/include/c++/10/bits/unordered_map.h" 3 void rehash(size_type __n) { _M_h.rehash(__n); } # 1979 "/usr/include/c++/10/bits/unordered_map.h" 3 void reserve(size_type __n) { _M_h.reserve(__n); } template friend bool operator==(const unordered_multimap<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, const unordered_multimap<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); }; template>, typename _Pred = equal_to<__iter_key_t<_InputIterator>>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, unordered_multimap::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, _Pred, _Allocator>; template, typename _Pred = equal_to<_Key>, typename _Allocator = allocator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_multimap(initializer_list>, unordered_multimap::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, unordered_multimap::size_type, _Allocator) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, _Allocator) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, hash<__iter_key_t<_InputIterator>>, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireAllocator<_Allocator>> unordered_multimap(_InputIterator, _InputIterator, unordered_multimap::size_type, _Hash, _Allocator) -> unordered_multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Hash, equal_to<__iter_key_t<_InputIterator>>, _Allocator>; template> unordered_multimap(initializer_list>, unordered_multimap::size_type, _Allocator) -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template> unordered_multimap(initializer_list>, _Allocator) -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multimap(initializer_list>, unordered_multimap::size_type, _Hash, _Allocator) -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; template inline void swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline void swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline bool operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return __x._M_h._M_equal(__y._M_h); } # 2102 "/usr/include/c++/10/bits/unordered_map.h" 3 template inline bool operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) { return __x._M_h._M_equal(__y._M_h); } # 2116 "/usr/include/c++/10/bits/unordered_map.h" 3 template struct _Hash_merge_helper< std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2> { private: template using unordered_map = std::unordered_map<_Tp...>; template using unordered_multimap = std::unordered_multimap<_Tp...>; friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>; static auto& _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } static auto& _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } }; template struct _Hash_merge_helper< std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2> { private: template using unordered_map = std::unordered_map<_Tp...>; template using unordered_multimap = std::unordered_multimap<_Tp...>; friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>; static auto& _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } static auto& _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) { return __map._M_h; } }; } # 48 "/usr/include/c++/10/unordered_map" 2 3 # 1 "/usr/include/c++/10/bits/erase_if.h" 1 3 # 33 "/usr/include/c++/10/bits/erase_if.h" 3 # 34 "/usr/include/c++/10/bits/erase_if.h" 3 namespace std { namespace __detail { template typename _Container::size_type __erase_nodes_if(_Container& __cont, _Predicate __pred) { typename _Container::size_type __num = 0; for (auto __iter = __cont.begin(), __last = __cont.end(); __iter != __last;) { if (__pred(*__iter)) { __iter = __cont.erase(__iter); ++__num; } else ++__iter; } return __num; } } } # 50 "/usr/include/c++/10/unordered_map" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template, typename _Pred = std::equal_to<_Key>> using unordered_map = std::unordered_map<_Key, _Tp, _Hash, _Pred, polymorphic_allocator>>; template, typename _Pred = std::equal_to<_Key>> using unordered_multimap = std::unordered_multimap<_Key, _Tp, _Hash, _Pred, polymorphic_allocator>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>::size_type erase_if(unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } template inline typename unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>:: size_type erase_if(unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } } # 62 "/usr/include/c++/10/functional" 2 3 # 1 "/usr/include/c++/10/vector" 1 3 # 58 "/usr/include/c++/10/vector" 3 # 59 "/usr/include/c++/10/vector" 3 # 1 "/usr/include/c++/10/bits/stl_uninitialized.h" 1 3 # 69 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct __uninitialized_copy { template static _ForwardIterator __uninit_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result) { _ForwardIterator __cur = __result; try { for (; __first != __last; ++__first, (void)++__cur) std::_Construct(std::__addressof(*__cur), *__first); return __cur; } catch(...) { std::_Destroy(__result, __cur); throw; } } }; template<> struct __uninitialized_copy { template static _ForwardIterator __uninit_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result) { return std::copy(__first, __last, __result); } }; # 123 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; static_assert(is_constructible<_ValueType2, decltype(*__first)>::value, "result type must be constructible from value type of input range"); typedef typename iterator_traits<_InputIterator>::reference _RefType1; typedef typename iterator_traits<_ForwardIterator>::reference _RefType2; const bool __assignable = is_assignable<_RefType2, _RefType1>::value; return std::__uninitialized_copy<__is_trivial(_ValueType1) && __is_trivial(_ValueType2) && __assignable>:: __uninit_copy(__first, __last, __result); } template struct __uninitialized_fill { template static void __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x) { _ForwardIterator __cur = __first; try { for (; __cur != __last; ++__cur) std::_Construct(std::__addressof(*__cur), __x); } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_fill { template static void __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x) { std::fill(__first, __last, __x); } }; # 198 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; static_assert(is_constructible<_ValueType, const _Tp&>::value, "result type must be constructible from input type"); const bool __assignable = is_copy_assignable<_ValueType>::value; std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>:: __uninit_fill(__first, __last, __x); } template struct __uninitialized_fill_n { template static _ForwardIterator __uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) { _ForwardIterator __cur = __first; try { for (; __n > 0; --__n, (void) ++__cur) std::_Construct(std::__addressof(*__cur), __x); return __cur; } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_fill_n { template static _ForwardIterator __uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) { return std::fill_n(__first, __n, __x); } }; # 270 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; static_assert(is_constructible<_ValueType, const _Tp&>::value, "result type must be constructible from input type"); const bool __assignable = is_copy_assignable<_ValueType>::value; return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>:: __uninit_fill_n(__first, __n, __x); } # 300 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) { _ForwardIterator __cur = __result; try { typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __first != __last; ++__first, (void)++__cur) __traits::construct(__alloc, std::__addressof(*__cur), *__first); return __cur; } catch(...) { std::_Destroy(__result, __cur, __alloc); throw; } } template inline _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, allocator<_Tp>&) { return std::uninitialized_copy(__first, __last, __result); } template inline _ForwardIterator __uninitialized_move_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) { return std::__uninitialized_copy_a(std::make_move_iterator(__first), std::make_move_iterator(__last), __result, __alloc); } template inline _ForwardIterator __uninitialized_move_if_noexcept_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) { return std::__uninitialized_copy_a (std::__make_move_if_noexcept_iterator(__first), std::__make_move_if_noexcept_iterator(__last), __result, __alloc); } template void __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, _Allocator& __alloc) { _ForwardIterator __cur = __first; try { typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __cur != __last; ++__cur) __traits::construct(__alloc, std::__addressof(*__cur), __x); } catch(...) { std::_Destroy(__first, __cur, __alloc); throw; } } template inline void __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x, allocator<_Tp2>&) { std::uninitialized_fill(__first, __last, __x); } template _ForwardIterator __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, const _Tp& __x, _Allocator& __alloc) { _ForwardIterator __cur = __first; try { typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __n > 0; --__n, (void) ++__cur) __traits::construct(__alloc, std::__addressof(*__cur), __x); return __cur; } catch(...) { std::_Destroy(__first, __cur, __alloc); throw; } } template inline _ForwardIterator __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, const _Tp& __x, allocator<_Tp2>&) { return std::uninitialized_fill_n(__first, __n, __x); } # 414 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline _ForwardIterator __uninitialized_copy_move(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _ForwardIterator __result, _Allocator& __alloc) { _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, __result, __alloc); try { return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); } catch(...) { std::_Destroy(__result, __mid, __alloc); throw; } } template inline _ForwardIterator __uninitialized_move_copy(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _ForwardIterator __result, _Allocator& __alloc) { _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, __result, __alloc); try { return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); } catch(...) { std::_Destroy(__result, __mid, __alloc); throw; } } template inline _ForwardIterator __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, const _Tp& __x, _InputIterator __first, _InputIterator __last, _Allocator& __alloc) { std::__uninitialized_fill_a(__result, __mid, __x, __alloc); try { return std::__uninitialized_move_a(__first, __last, __mid, __alloc); } catch(...) { std::_Destroy(__result, __mid, __alloc); throw; } } template inline void __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, _ForwardIterator __first2, _ForwardIterator __last2, const _Tp& __x, _Allocator& __alloc) { _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, __first2, __alloc); try { std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); } catch(...) { std::_Destroy(__first2, __mid2, __alloc); throw; } } # 521 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template struct __uninitialized_default_1 { template static void __uninit_default(_ForwardIterator __first, _ForwardIterator __last) { _ForwardIterator __cur = __first; try { for (; __cur != __last; ++__cur) std::_Construct(std::__addressof(*__cur)); } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_default_1 { template static void __uninit_default(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; std::fill(__first, __last, _ValueType()); } }; template struct __uninitialized_default_n_1 { template static _ForwardIterator __uninit_default_n(_ForwardIterator __first, _Size __n) { _ForwardIterator __cur = __first; try { for (; __n > 0; --__n, (void) ++__cur) std::_Construct(std::__addressof(*__cur)); return __cur; } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_default_n_1 { template static _ForwardIterator __uninit_default_n(_ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; return std::fill_n(__first, __n, _ValueType()); } }; template inline void __uninitialized_default(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; const bool __assignable = is_copy_assignable<_ValueType>::value; std::__uninitialized_default_1<__is_trivial(_ValueType) && __assignable>:: __uninit_default(__first, __last); } template inline _ForwardIterator __uninitialized_default_n(_ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; const bool __assignable = is_copy_assignable<_ValueType>::value; return __uninitialized_default_n_1<__is_trivial(_ValueType) && __assignable>:: __uninit_default_n(__first, __n); } template void __uninitialized_default_a(_ForwardIterator __first, _ForwardIterator __last, _Allocator& __alloc) { _ForwardIterator __cur = __first; try { typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __cur != __last; ++__cur) __traits::construct(__alloc, std::__addressof(*__cur)); } catch(...) { std::_Destroy(__first, __cur, __alloc); throw; } } template inline void __uninitialized_default_a(_ForwardIterator __first, _ForwardIterator __last, allocator<_Tp>&) { std::__uninitialized_default(__first, __last); } template _ForwardIterator __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, _Allocator& __alloc) { _ForwardIterator __cur = __first; try { typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; for (; __n > 0; --__n, (void) ++__cur) __traits::construct(__alloc, std::__addressof(*__cur)); return __cur; } catch(...) { std::_Destroy(__first, __cur, __alloc); throw; } } template inline _ForwardIterator __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, allocator<_Tp>&) { return std::__uninitialized_default_n(__first, __n); } template struct __uninitialized_default_novalue_1 { template static void __uninit_default_novalue(_ForwardIterator __first, _ForwardIterator __last) { _ForwardIterator __cur = __first; try { for (; __cur != __last; ++__cur) std::_Construct_novalue(std::__addressof(*__cur)); } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_default_novalue_1 { template static void __uninit_default_novalue(_ForwardIterator __first, _ForwardIterator __last) { } }; template struct __uninitialized_default_novalue_n_1 { template static _ForwardIterator __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) { _ForwardIterator __cur = __first; try { for (; __n > 0; --__n, (void) ++__cur) std::_Construct_novalue(std::__addressof(*__cur)); return __cur; } catch(...) { std::_Destroy(__first, __cur); throw; } } }; template<> struct __uninitialized_default_novalue_n_1 { template static _ForwardIterator __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) { return std::next(__first, __n); } }; template inline void __uninitialized_default_novalue(_ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; std::__uninitialized_default_novalue_1< is_trivially_default_constructible<_ValueType>::value>:: __uninit_default_novalue(__first, __last); } template inline _ForwardIterator __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; return __uninitialized_default_novalue_n_1< is_trivially_default_constructible<_ValueType>::value>:: __uninit_default_novalue_n(__first, __n); } template _ForwardIterator __uninitialized_copy_n(_InputIterator __first, _Size __n, _ForwardIterator __result, input_iterator_tag) { _ForwardIterator __cur = __result; try { for (; __n > 0; --__n, (void) ++__first, ++__cur) std::_Construct(std::__addressof(*__cur), *__first); return __cur; } catch(...) { std::_Destroy(__result, __cur); throw; } } template inline _ForwardIterator __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, _ForwardIterator __result, random_access_iterator_tag) { return std::uninitialized_copy(__first, __first + __n, __result); } template pair<_InputIterator, _ForwardIterator> __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, _ForwardIterator __result, input_iterator_tag) { _ForwardIterator __cur = __result; try { for (; __n > 0; --__n, (void) ++__first, ++__cur) std::_Construct(std::__addressof(*__cur), *__first); return {__first, __cur}; } catch(...) { std::_Destroy(__result, __cur); throw; } } template inline pair<_RandomAccessIterator, _ForwardIterator> __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, _ForwardIterator __result, random_access_iterator_tag) { auto __second_res = uninitialized_copy(__first, __first + __n, __result); auto __first_res = std::next(__first, __n); return {__first_res, __second_res}; } # 852 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_copy_n(_InputIterator __first, _Size __n, _ForwardIterator __result) { return std::__uninitialized_copy_n(__first, __n, __result, std::__iterator_category(__first)); } template inline pair<_InputIterator, _ForwardIterator> __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, _ForwardIterator __result) { return std::__uninitialized_copy_n_pair(__first, __n, __result, std::__iterator_category(__first)); } # 880 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) { __uninitialized_default_novalue(__first, __last); } template inline _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) { return __uninitialized_default_novalue_n(__first, __count); } template inline void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) { return __uninitialized_default(__first, __last); } template inline _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) { return __uninitialized_default_n(__first, __count); } # 934 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline _ForwardIterator uninitialized_move(_InputIterator __first, _InputIterator __last, _ForwardIterator __result) { return std::uninitialized_copy (std::make_move_iterator(__first), std::make_move_iterator(__last), __result); } # 951 "/usr/include/c++/10/bits/stl_uninitialized.h" 3 template inline pair<_InputIterator, _ForwardIterator> uninitialized_move_n(_InputIterator __first, _Size __count, _ForwardIterator __result) { auto __res = std::__uninitialized_copy_n_pair (std::make_move_iterator(__first), __count, __result); return {__res.first.base(), __res.second}; } template inline void __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, _Allocator& __alloc) noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, __dest, std::move(*__orig))) && noexcept(std::allocator_traits<_Allocator>::destroy( __alloc, std::__addressof(*__orig)))) { typedef std::allocator_traits<_Allocator> __traits; __traits::construct(__alloc, __dest, std::move(*__orig)); __traits::destroy(__alloc, std::__addressof(*__orig)); } template struct __is_bitwise_relocatable : is_trivial<_Tp> { }; template inline __enable_if_t::value, _Tp*> __relocate_a_1(_Tp* __first, _Tp* __last, _Tp* __result, allocator<_Up>&) noexcept { ptrdiff_t __count = __last - __first; if (__count > 0) __builtin_memmove(__result, __first, __count * sizeof(_Tp)); return __result + __count; } template inline _ForwardIterator __relocate_a_1(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), std::addressof(*__first), __alloc))) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; static_assert(std::is_same<_ValueType, _ValueType2>::value, "relocation is only possible for values of the same type"); _ForwardIterator __cur = __result; for (; __first != __last; ++__first, (void)++__cur) std::__relocate_object_a(std::__addressof(*__cur), std::__addressof(*__first), __alloc); return __cur; } template inline _ForwardIterator __relocate_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result), __alloc))) { return __relocate_a_1(std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result), __alloc); } } # 67 "/usr/include/c++/10/vector" 2 3 # 1 "/usr/include/c++/10/bits/stl_vector.h" 1 3 # 77 "/usr/include/c++/10/bits/stl_vector.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct _Vector_base { typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type; typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer pointer; struct _Vector_impl_data { pointer _M_start; pointer _M_finish; pointer _M_end_of_storage; _Vector_impl_data() noexcept : _M_start(), _M_finish(), _M_end_of_storage() { } _Vector_impl_data(_Vector_impl_data&& __x) noexcept : _M_start(__x._M_start), _M_finish(__x._M_finish), _M_end_of_storage(__x._M_end_of_storage) { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); } void _M_copy_data(_Vector_impl_data const& __x) noexcept { _M_start = __x._M_start; _M_finish = __x._M_finish; _M_end_of_storage = __x._M_end_of_storage; } void _M_swap_data(_Vector_impl_data& __x) noexcept { _Vector_impl_data __tmp; __tmp._M_copy_data(*this); _M_copy_data(__x); __x._M_copy_data(__tmp); } }; struct _Vector_impl : public _Tp_alloc_type, public _Vector_impl_data { _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) : _Tp_alloc_type() { } _Vector_impl(_Tp_alloc_type const& __a) noexcept : _Tp_alloc_type(__a) { } _Vector_impl(_Vector_impl&& __x) noexcept : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x)) { } _Vector_impl(_Tp_alloc_type&& __a) noexcept : _Tp_alloc_type(std::move(__a)) { } _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv)) { } # 270 "/usr/include/c++/10/bits/stl_vector.h" 3 }; public: typedef _Alloc allocator_type; _Tp_alloc_type& _M_get_Tp_allocator() noexcept { return this->_M_impl; } const _Tp_alloc_type& _M_get_Tp_allocator() const noexcept { return this->_M_impl; } allocator_type get_allocator() const noexcept { return allocator_type(_M_get_Tp_allocator()); } _Vector_base() = default; _Vector_base(const allocator_type& __a) noexcept : _M_impl(__a) { } _Vector_base(size_t __n) : _M_impl() { _M_create_storage(__n); } _Vector_base(size_t __n, const allocator_type& __a) : _M_impl(__a) { _M_create_storage(__n); } _Vector_base(_Vector_base&&) = default; _Vector_base(_Tp_alloc_type&& __a) noexcept : _M_impl(std::move(__a)) { } _Vector_base(_Vector_base&& __x, const allocator_type& __a) : _M_impl(__a) { if (__x.get_allocator() == __a) this->_M_impl._M_swap_data(__x._M_impl); else { size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; _M_create_storage(__n); } } _Vector_base(const allocator_type& __a, _Vector_base&& __x) : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl)) { } ~_Vector_base() noexcept { _M_deallocate(_M_impl._M_start, _M_impl._M_end_of_storage - _M_impl._M_start); } public: _Vector_impl _M_impl; pointer _M_allocate(size_t __n) { typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer(); } void _M_deallocate(pointer __p, size_t __n) { typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; if (__p) _Tr::deallocate(_M_impl, __p, __n); } protected: void _M_create_storage(size_t __n) { this->_M_impl._M_start = this->_M_allocate(__n); this->_M_impl._M_finish = this->_M_impl._M_start; this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; } }; # 388 "/usr/include/c++/10/bits/stl_vector.h" 3 template > class vector : protected _Vector_base<_Tp, _Alloc> { # 401 "/usr/include/c++/10/bits/stl_vector.h" 3 static_assert(is_same::type, _Tp>::value, "std::vector must have a non-const, non-volatile value_type"); static_assert(is_same::value, "std::vector must have the same value_type as its allocator"); typedef _Vector_base<_Tp, _Alloc> _Base; typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; public: typedef _Tp value_type; typedef typename _Base::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef __gnu_cxx::__normal_iterator iterator; typedef __gnu_cxx::__normal_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Alloc allocator_type; private: static constexpr bool _S_nothrow_relocate(true_type) { return noexcept(std::__relocate_a(std::declval(), std::declval(), std::declval(), std::declval<_Tp_alloc_type&>())); } static constexpr bool _S_nothrow_relocate(false_type) { return false; } static constexpr bool _S_use_relocate() { return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{}); } static pointer _S_do_relocate(pointer __first, pointer __last, pointer __result, _Tp_alloc_type& __alloc, true_type) noexcept { return std::__relocate_a(__first, __last, __result, __alloc); } static pointer _S_do_relocate(pointer, pointer, pointer __result, _Tp_alloc_type&, false_type) noexcept { return __result; } static pointer _S_relocate(pointer __first, pointer __last, pointer __result, _Tp_alloc_type& __alloc) noexcept { using __do_it = __bool_constant<_S_use_relocate()>; return _S_do_relocate(__first, __last, __result, __alloc, __do_it{}); } protected: using _Base::_M_allocate; using _Base::_M_deallocate; using _Base::_M_impl; using _Base::_M_get_Tp_allocator; public: vector() = default; # 496 "/usr/include/c++/10/bits/stl_vector.h" 3 explicit vector(const allocator_type& __a) noexcept : _Base(__a) { } # 509 "/usr/include/c++/10/bits/stl_vector.h" 3 explicit vector(size_type __n, const allocator_type& __a = allocator_type()) : _Base(_S_check_init_len(__n, __a), __a) { _M_default_initialize(__n); } # 522 "/usr/include/c++/10/bits/stl_vector.h" 3 vector(size_type __n, const value_type& __value, const allocator_type& __a = allocator_type()) : _Base(_S_check_init_len(__n, __a), __a) { _M_fill_initialize(__n, __value); } # 553 "/usr/include/c++/10/bits/stl_vector.h" 3 vector(const vector& __x) : _Base(__x.size(), _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) { this->_M_impl._M_finish = std::__uninitialized_copy_a(__x.begin(), __x.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); } # 572 "/usr/include/c++/10/bits/stl_vector.h" 3 vector(vector&&) noexcept = default; vector(const vector& __x, const allocator_type& __a) : _Base(__x.size(), __a) { this->_M_impl._M_finish = std::__uninitialized_copy_a(__x.begin(), __x.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); } private: vector(vector&& __rv, const allocator_type& __m, true_type) noexcept : _Base(__m, std::move(__rv)) { } vector(vector&& __rv, const allocator_type& __m, false_type) : _Base(__m) { if (__rv.get_allocator() == __m) this->_M_impl._M_swap_data(__rv._M_impl); else if (!__rv.empty()) { this->_M_create_storage(__rv.size()); this->_M_impl._M_finish = std::__uninitialized_move_a(__rv.begin(), __rv.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); __rv.clear(); } } public: vector(vector&& __rv, const allocator_type& __m) noexcept( noexcept( vector(std::declval(), std::declval(), std::declval())) ) : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{}) { } # 625 "/usr/include/c++/10/bits/stl_vector.h" 3 vector(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_range_initialize(__l.begin(), __l.end(), random_access_iterator_tag()); } # 651 "/usr/include/c++/10/bits/stl_vector.h" 3 template> vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_range_initialize(__first, __last, std::__iterator_category(__first)); } # 678 "/usr/include/c++/10/bits/stl_vector.h" 3 ~vector() noexcept { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; } # 694 "/usr/include/c++/10/bits/stl_vector.h" 3 vector& operator=(const vector& __x); # 708 "/usr/include/c++/10/bits/stl_vector.h" 3 vector& operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) { constexpr bool __move_storage = _Alloc_traits::_S_propagate_on_move_assign() || _Alloc_traits::_S_always_equal(); _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); return *this; } # 729 "/usr/include/c++/10/bits/stl_vector.h" 3 vector& operator=(initializer_list __l) { this->_M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); return *this; } # 748 "/usr/include/c++/10/bits/stl_vector.h" 3 void assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); } # 765 "/usr/include/c++/10/bits/stl_vector.h" 3 template> void assign(_InputIterator __first, _InputIterator __last) { _M_assign_dispatch(__first, __last, __false_type()); } # 793 "/usr/include/c++/10/bits/stl_vector.h" 3 void assign(initializer_list __l) { this->_M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } using _Base::get_allocator; iterator begin() noexcept { return iterator(this->_M_impl._M_start); } const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_start); } iterator end() noexcept { return iterator(this->_M_impl._M_finish); } const_iterator end() const noexcept { return const_iterator(this->_M_impl._M_finish); } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return const_iterator(this->_M_impl._M_start); } const_iterator cend() const noexcept { return const_iterator(this->_M_impl._M_finish); } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } size_type size() const noexcept { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } size_type max_size() const noexcept { return _S_max_size(_M_get_Tp_allocator()); } # 936 "/usr/include/c++/10/bits/stl_vector.h" 3 void resize(size_type __new_size) { if (__new_size > size()) _M_default_append(__new_size - size()); else if (__new_size < size()) _M_erase_at_end(this->_M_impl._M_start + __new_size); } # 956 "/usr/include/c++/10/bits/stl_vector.h" 3 void resize(size_type __new_size, const value_type& __x) { if (__new_size > size()) _M_fill_insert(end(), __new_size - size(), __x); else if (__new_size < size()) _M_erase_at_end(this->_M_impl._M_start + __new_size); } # 988 "/usr/include/c++/10/bits/stl_vector.h" 3 void shrink_to_fit() { _M_shrink_to_fit(); } size_type capacity() const noexcept { return size_type(this->_M_impl._M_end_of_storage - this->_M_impl._M_start); } [[__nodiscard__]] bool empty() const noexcept { return begin() == end(); } # 1027 "/usr/include/c++/10/bits/stl_vector.h" 3 void reserve(size_type __n); # 1042 "/usr/include/c++/10/bits/stl_vector.h" 3 reference operator[](size_type __n) noexcept { ; return *(this->_M_impl._M_start + __n); } # 1060 "/usr/include/c++/10/bits/stl_vector.h" 3 const_reference operator[](size_type __n) const noexcept { ; return *(this->_M_impl._M_start + __n); } protected: void _M_range_check(size_type __n) const { if (__n >= this->size()) __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); } public: # 1091 "/usr/include/c++/10/bits/stl_vector.h" 3 reference at(size_type __n) { _M_range_check(__n); return (*this)[__n]; } # 1109 "/usr/include/c++/10/bits/stl_vector.h" 3 const_reference at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } reference front() noexcept { ; return *begin(); } const_reference front() const noexcept { ; return *begin(); } reference back() noexcept { ; return *(end() - 1); } const_reference back() const noexcept { ; return *(end() - 1); } # 1167 "/usr/include/c++/10/bits/stl_vector.h" 3 _Tp* data() noexcept { return _M_data_ptr(this->_M_impl._M_start); } const _Tp* data() const noexcept { return _M_data_ptr(this->_M_impl._M_start); } # 1186 "/usr/include/c++/10/bits/stl_vector.h" 3 void push_back(const value_type& __x) { if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x); ++this->_M_impl._M_finish; ; } else _M_realloc_insert(end(), __x); } void push_back(value_type&& __x) { emplace_back(std::move(__x)); } template reference emplace_back(_Args&&... __args); # 1224 "/usr/include/c++/10/bits/stl_vector.h" 3 void pop_back() noexcept { ; --this->_M_impl._M_finish; _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); ; } # 1246 "/usr/include/c++/10/bits/stl_vector.h" 3 template iterator emplace(const_iterator __position, _Args&&... __args) { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); } # 1262 "/usr/include/c++/10/bits/stl_vector.h" 3 iterator insert(const_iterator __position, const value_type& __x); # 1292 "/usr/include/c++/10/bits/stl_vector.h" 3 iterator insert(const_iterator __position, value_type&& __x) { return _M_insert_rval(__position, std::move(__x)); } # 1309 "/usr/include/c++/10/bits/stl_vector.h" 3 iterator insert(const_iterator __position, initializer_list __l) { auto __offset = __position - cbegin(); _M_range_insert(begin() + __offset, __l.begin(), __l.end(), std::random_access_iterator_tag()); return begin() + __offset; } # 1334 "/usr/include/c++/10/bits/stl_vector.h" 3 iterator insert(const_iterator __position, size_type __n, const value_type& __x) { difference_type __offset = __position - cbegin(); _M_fill_insert(begin() + __offset, __n, __x); return begin() + __offset; } # 1376 "/usr/include/c++/10/bits/stl_vector.h" 3 template> iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { difference_type __offset = __position - cbegin(); _M_insert_dispatch(begin() + __offset, __first, __last, __false_type()); return begin() + __offset; } # 1428 "/usr/include/c++/10/bits/stl_vector.h" 3 iterator erase(const_iterator __position) { return _M_erase(begin() + (__position - cbegin())); } # 1455 "/usr/include/c++/10/bits/stl_vector.h" 3 iterator erase(const_iterator __first, const_iterator __last) { const auto __beg = begin(); const auto __cbeg = cbegin(); return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); } # 1479 "/usr/include/c++/10/bits/stl_vector.h" 3 void swap(vector& __x) noexcept { ; this->_M_impl._M_swap_data(__x._M_impl); _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } void clear() noexcept { _M_erase_at_end(this->_M_impl._M_start); } protected: template pointer _M_allocate_and_copy(size_type __n, _ForwardIterator __first, _ForwardIterator __last) { pointer __result = this->_M_allocate(__n); try { std::__uninitialized_copy_a(__first, __last, __result, _M_get_Tp_allocator()); return __result; } catch(...) { _M_deallocate(__result, __n); throw; } } # 1556 "/usr/include/c++/10/bits/stl_vector.h" 3 template void _M_range_initialize(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { try { for (; __first != __last; ++__first) emplace_back(*__first); } catch(...) { clear(); throw; } } template void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); this->_M_impl._M_start = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator())); this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; this->_M_impl._M_finish = std::__uninitialized_copy_a(__first, __last, this->_M_impl._M_start, _M_get_Tp_allocator()); } void _M_fill_initialize(size_type __n, const value_type& __value) { this->_M_impl._M_finish = std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, _M_get_Tp_allocator()); } void _M_default_initialize(size_type __n) { this->_M_impl._M_finish = std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, _M_get_Tp_allocator()); } # 1618 "/usr/include/c++/10/bits/stl_vector.h" 3 template void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) { _M_fill_assign(__n, __val); } template void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } template void _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag); template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); void _M_fill_assign(size_type __n, const value_type& __val); template void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, __true_type) { _M_fill_insert(__pos, __n, __val); } template void _M_insert_dispatch(iterator __pos, _InputIterator __first, _InputIterator __last, __false_type) { _M_range_insert(__pos, __first, __last, std::__iterator_category(__first)); } template void _M_range_insert(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag); template void _M_range_insert(iterator __pos, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); void _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); void _M_default_append(size_type __n); bool _M_shrink_to_fit(); # 1705 "/usr/include/c++/10/bits/stl_vector.h" 3 struct _Temporary_value { template explicit _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec) { _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(), std::forward<_Args>(__args)...); } ~_Temporary_value() { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); } value_type& _M_val() { return *_M_ptr(); } private: _Tp* _M_ptr() { return reinterpret_cast<_Tp*>(&__buf); } vector* _M_this; typename aligned_storage::type __buf; }; template void _M_insert_aux(iterator __position, _Arg&& __arg); template void _M_realloc_insert(iterator __position, _Args&&... __args); iterator _M_insert_rval(const_iterator __position, value_type&& __v); template iterator _M_emplace_aux(const_iterator __position, _Args&&... __args); iterator _M_emplace_aux(const_iterator __position, value_type&& __v) { return _M_insert_rval(__position, std::move(__v)); } size_type _M_check_len(size_type __n, const char* __s) const { if (max_size() - size() < __n) __throw_length_error((__s)); const size_type __len = size() + (std::max)(size(), __n); return (__len < size() || __len > max_size()) ? max_size() : __len; } static size_type _S_check_init_len(size_type __n, const allocator_type& __a) { if (__n > _S_max_size(_Tp_alloc_type(__a))) __throw_length_error( ("cannot create std::vector larger than max_size()")); return __n; } static size_type _S_max_size(const _Tp_alloc_type& __a) noexcept { const size_t __diffmax = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); const size_t __allocmax = _Alloc_traits::max_size(__a); return (std::min)(__diffmax, __allocmax); } void _M_erase_at_end(pointer __pos) noexcept { if (size_type __n = this->_M_impl._M_finish - __pos) { std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __pos; ; } } iterator _M_erase(iterator __position); iterator _M_erase(iterator __first, iterator __last); private: void _M_move_assign(vector&& __x, true_type) noexcept { vector __tmp(get_allocator()); this->_M_impl._M_swap_data(__x._M_impl); __tmp._M_impl._M_swap_data(__x._M_impl); std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } void _M_move_assign(vector&& __x, false_type) { if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) _M_move_assign(std::move(__x), true_type()); else { this->_M_assign_aux(std::make_move_iterator(__x.begin()), std::make_move_iterator(__x.end()), std::random_access_iterator_tag()); __x.clear(); } } template _Up* _M_data_ptr(_Up* __ptr) const noexcept { return __ptr; } template typename std::pointer_traits<_Ptr>::element_type* _M_data_ptr(_Ptr __ptr) const { return empty() ? nullptr : std::__to_address(__ptr); } # 1868 "/usr/include/c++/10/bits/stl_vector.h" 3 }; template::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>> vector(_InputIterator, _InputIterator, _Allocator = _Allocator()) -> vector<_ValT, _Allocator>; # 1890 "/usr/include/c++/10/bits/stl_vector.h" 3 template inline bool operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return (__x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin())); } # 1908 "/usr/include/c++/10/bits/stl_vector.h" 3 template inline __detail::__synth3way_t<_Tp> operator<=>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) { return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __detail::__synth3way); } # 1960 "/usr/include/c++/10/bits/stl_vector.h" 3 template inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::is_nothrow_move_assignable> { }; } } # 68 "/usr/include/c++/10/vector" 2 3 # 1 "/usr/include/c++/10/bits/stl_bvector.h" 1 3 # 64 "/usr/include/c++/10/bits/stl_bvector.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { typedef unsigned long _Bit_type; enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; struct _Bit_reference { _Bit_type * _M_p; _Bit_type _M_mask; _Bit_reference(_Bit_type * __x, _Bit_type __y) : _M_p(__x), _M_mask(__y) { } _Bit_reference() noexcept : _M_p(0), _M_mask(0) { } _Bit_reference(const _Bit_reference&) = default; operator bool() const noexcept { return !!(*_M_p & _M_mask); } _Bit_reference& operator=(bool __x) noexcept { if (__x) *_M_p |= _M_mask; else *_M_p &= ~_M_mask; return *this; } _Bit_reference& operator=(const _Bit_reference& __x) noexcept { return *this = bool(__x); } bool operator==(const _Bit_reference& __x) const { return bool(*this) == bool(__x); } bool operator<(const _Bit_reference& __x) const { return !bool(*this) && bool(__x); } void flip() noexcept { *_M_p ^= _M_mask; } }; inline void swap(_Bit_reference __x, _Bit_reference __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } inline void swap(_Bit_reference __x, bool& __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } inline void swap(bool& __x, _Bit_reference __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } struct _Bit_iterator_base : public std::iterator { _Bit_type * _M_p; unsigned int _M_offset; _Bit_iterator_base(_Bit_type * __x, unsigned int __y) : _M_p(__x), _M_offset(__y) { } void _M_bump_up() { if (_M_offset++ == int(_S_word_bit) - 1) { _M_offset = 0; ++_M_p; } } void _M_bump_down() { if (_M_offset-- == 0) { _M_offset = int(_S_word_bit) - 1; --_M_p; } } void _M_incr(ptrdiff_t __i) { difference_type __n = __i + _M_offset; _M_p += __n / int(_S_word_bit); __n = __n % int(_S_word_bit); if (__n < 0) { __n += int(_S_word_bit); --_M_p; } _M_offset = static_cast(__n); } friend constexpr bool operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; } friend constexpr strong_ordering operator<=>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) noexcept { if (const auto __cmp = __x._M_p <=> __y._M_p; __cmp != 0) return __cmp; return __x._M_offset <=> __y._M_offset; } # 223 "/usr/include/c++/10/bits/stl_bvector.h" 3 friend ptrdiff_t operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { return (int(_S_word_bit) * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset); } }; struct _Bit_iterator : public _Bit_iterator_base { typedef _Bit_reference reference; typedef void pointer; typedef _Bit_iterator iterator; _Bit_iterator() : _Bit_iterator_base(0, 0) { } _Bit_iterator(_Bit_type * __x, unsigned int __y) : _Bit_iterator_base(__x, __y) { } iterator _M_const_cast() const { return *this; } reference operator*() const { return reference(_M_p, 1UL << _M_offset); } iterator& operator++() { _M_bump_up(); return *this; } iterator operator++(int) { iterator __tmp = *this; _M_bump_up(); return __tmp; } iterator& operator--() { _M_bump_down(); return *this; } iterator operator--(int) { iterator __tmp = *this; _M_bump_down(); return __tmp; } iterator& operator+=(difference_type __i) { _M_incr(__i); return *this; } iterator& operator-=(difference_type __i) { *this += -__i; return *this; } reference operator[](difference_type __i) const { return *(*this + __i); } friend iterator operator+(const iterator& __x, difference_type __n) { iterator __tmp = __x; __tmp += __n; return __tmp; } friend iterator operator+(difference_type __n, const iterator& __x) { return __x + __n; } friend iterator operator-(const iterator& __x, difference_type __n) { iterator __tmp = __x; __tmp -= __n; return __tmp; } }; struct _Bit_const_iterator : public _Bit_iterator_base { typedef bool reference; typedef bool const_reference; typedef void pointer; typedef _Bit_const_iterator const_iterator; _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } _Bit_const_iterator(_Bit_type * __x, unsigned int __y) : _Bit_iterator_base(__x, __y) { } _Bit_const_iterator(const _Bit_iterator& __x) : _Bit_iterator_base(__x._M_p, __x._M_offset) { } _Bit_iterator _M_const_cast() const { return _Bit_iterator(_M_p, _M_offset); } const_reference operator*() const { return _Bit_reference(_M_p, 1UL << _M_offset); } const_iterator& operator++() { _M_bump_up(); return *this; } const_iterator operator++(int) { const_iterator __tmp = *this; _M_bump_up(); return __tmp; } const_iterator& operator--() { _M_bump_down(); return *this; } const_iterator operator--(int) { const_iterator __tmp = *this; _M_bump_down(); return __tmp; } const_iterator& operator+=(difference_type __i) { _M_incr(__i); return *this; } const_iterator& operator-=(difference_type __i) { *this += -__i; return *this; } const_reference operator[](difference_type __i) const { return *(*this + __i); } friend const_iterator operator+(const const_iterator& __x, difference_type __n) { const_iterator __tmp = __x; __tmp += __n; return __tmp; } friend const_iterator operator-(const const_iterator& __x, difference_type __n) { const_iterator __tmp = __x; __tmp -= __n; return __tmp; } friend const_iterator operator+(difference_type __n, const const_iterator& __x) { return __x + __n; } }; inline void __fill_bvector(_Bit_type * __v, unsigned int __first, unsigned int __last, bool __x) { const _Bit_type __fmask = ~0ul << __first; const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last); const _Bit_type __mask = __fmask & __lmask; if (__x) *__v |= __mask; else *__v &= ~__mask; } inline void fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x) { if (__first._M_p != __last._M_p) { _Bit_type* __first_p = __first._M_p; if (__first._M_offset != 0) __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x); __builtin_memset(__first_p, __x ? ~0 : 0, (__last._M_p - __first_p) * sizeof(_Bit_type)); if (__last._M_offset != 0) __fill_bvector(__last._M_p, 0, __last._M_offset, __x); } else if (__first._M_offset != __last._M_offset) __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x); } template struct _Bvector_base { typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Bit_type>::other _Bit_alloc_type; typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type> _Bit_alloc_traits; typedef typename _Bit_alloc_traits::pointer _Bit_pointer; struct _Bvector_impl_data { _Bit_iterator _M_start; _Bit_iterator _M_finish; _Bit_pointer _M_end_of_storage; _Bvector_impl_data() noexcept : _M_start(), _M_finish(), _M_end_of_storage() { } _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept : _M_start(__x._M_start), _M_finish(__x._M_finish) , _M_end_of_storage(__x._M_end_of_storage) { __x._M_reset(); } void _M_move_data(_Bvector_impl_data&& __x) noexcept { this->_M_start = __x._M_start; this->_M_finish = __x._M_finish; this->_M_end_of_storage = __x._M_end_of_storage; __x._M_reset(); } void _M_reset() noexcept { _M_start = _M_finish = _Bit_iterator(); _M_end_of_storage = _Bit_pointer(); } }; struct _Bvector_impl : public _Bit_alloc_type, public _Bvector_impl_data { public: _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value) : _Bit_alloc_type() { } _Bvector_impl(const _Bit_alloc_type& __a) noexcept : _Bit_alloc_type(__a) { } _Bvector_impl(_Bvector_impl&&) = default; _Bit_type* _M_end_addr() const noexcept { if (this->_M_end_of_storage) return std::__addressof(this->_M_end_of_storage[-1]) + 1; return 0; } }; public: typedef _Alloc allocator_type; _Bit_alloc_type& _M_get_Bit_allocator() noexcept { return this->_M_impl; } const _Bit_alloc_type& _M_get_Bit_allocator() const noexcept { return this->_M_impl; } allocator_type get_allocator() const noexcept { return allocator_type(_M_get_Bit_allocator()); } _Bvector_base() = default; _Bvector_base(const allocator_type& __a) : _M_impl(__a) { } _Bvector_base(_Bvector_base&&) = default; ~_Bvector_base() { this->_M_deallocate(); } protected: _Bvector_impl _M_impl; _Bit_pointer _M_allocate(size_t __n) { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); } void _M_deallocate() { if (_M_impl._M_start._M_p) { const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p; _Bit_alloc_traits::deallocate(_M_impl, _M_impl._M_end_of_storage - __n, __n); _M_impl._M_reset(); } } void _M_move_data(_Bvector_base&& __x) noexcept { _M_impl._M_move_data(std::move(__x._M_impl)); } static size_t _S_nword(size_t __n) { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } }; } namespace std __attribute__ ((__visibility__ ("default"))) { # 614 "/usr/include/c++/10/bits/stl_bvector.h" 3 template class vector : protected _Bvector_base<_Alloc> { typedef _Bvector_base<_Alloc> _Base; typedef typename _Base::_Bit_pointer _Bit_pointer; typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits; friend struct std::hash; public: typedef bool value_type; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Bit_reference reference; typedef bool const_reference; typedef _Bit_reference* pointer; typedef const bool* const_pointer; typedef _Bit_iterator iterator; typedef _Bit_const_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; typedef _Alloc allocator_type; allocator_type get_allocator() const { return _Base::get_allocator(); } protected: using _Base::_M_allocate; using _Base::_M_deallocate; using _Base::_S_nword; using _Base::_M_get_Bit_allocator; public: vector() = default; explicit vector(const allocator_type& __a) : _Base(__a) { } explicit vector(size_type __n, const allocator_type& __a = allocator_type()) : vector(__n, false, __a) { } vector(size_type __n, const bool& __value, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_initialize(__n); _M_initialize_value(__value); } vector(const vector& __x) : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator())) { _M_initialize(__x.size()); _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start); } vector(vector&&) = default; vector(vector&& __x, const allocator_type& __a) noexcept(_Bit_alloc_traits::_S_always_equal()) : _Base(__a) { if (__x.get_allocator() == __a) this->_M_move_data(std::move(__x)); else { _M_initialize(__x.size()); _M_copy_aligned(__x.begin(), __x.end(), begin()); __x.clear(); } } vector(const vector& __x, const allocator_type& __a) : _Base(__a) { _M_initialize(__x.size()); _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start); } vector(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_initialize_range(__l.begin(), __l.end(), random_access_iterator_tag()); } template> vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_initialize_dispatch(__first, __last, __false_type()); } # 737 "/usr/include/c++/10/bits/stl_bvector.h" 3 ~vector() noexcept { } vector& operator=(const vector& __x) { if (&__x == this) return *this; if (_Bit_alloc_traits::_S_propagate_on_copy_assign()) { if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator()) { this->_M_deallocate(); std::__alloc_on_copy(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); _M_initialize(__x.size()); } else std::__alloc_on_copy(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); } if (__x.size() > capacity()) { this->_M_deallocate(); _M_initialize(__x.size()); } this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), begin()); return *this; } vector& operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move()) { if (_Bit_alloc_traits::_S_propagate_on_move_assign() || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator()) { this->_M_deallocate(); this->_M_move_data(std::move(__x)); std::__alloc_on_move(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); } else { if (__x.size() > capacity()) { this->_M_deallocate(); _M_initialize(__x.size()); } this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), begin()); __x.clear(); } return *this; } vector& operator=(initializer_list __l) { this->assign (__l.begin(), __l.end()); return *this; } void assign(size_type __n, const bool& __x) { _M_fill_assign(__n, __x); } template> void assign(_InputIterator __first, _InputIterator __last) { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } # 828 "/usr/include/c++/10/bits/stl_bvector.h" 3 void assign(initializer_list __l) { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } iterator begin() noexcept { return iterator(this->_M_impl._M_start._M_p, 0); } const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_start._M_p, 0); } iterator end() noexcept { return this->_M_impl._M_finish; } const_iterator end() const noexcept { return this->_M_impl._M_finish; } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return const_iterator(this->_M_impl._M_start._M_p, 0); } const_iterator cend() const noexcept { return this->_M_impl._M_finish; } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } size_type size() const noexcept { return size_type(end() - begin()); } size_type max_size() const noexcept { const size_type __isize = __gnu_cxx::__numeric_traits::__max - int(_S_word_bit) + 1; const size_type __asize = _Bit_alloc_traits::max_size(_M_get_Bit_allocator()); return (__asize <= __isize / int(_S_word_bit) ? __asize * int(_S_word_bit) : __isize); } size_type capacity() const noexcept { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0) - begin()); } [[__nodiscard__]] bool empty() const noexcept { return begin() == end(); } reference operator[](size_type __n) { return *iterator(this->_M_impl._M_start._M_p + __n / int(_S_word_bit), __n % int(_S_word_bit)); } const_reference operator[](size_type __n) const { return *const_iterator(this->_M_impl._M_start._M_p + __n / int(_S_word_bit), __n % int(_S_word_bit)); } protected: void _M_range_check(size_type __n) const { if (__n >= this->size()) __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)") , __n, this->size()); } public: reference at(size_type __n) { _M_range_check(__n); return (*this)[__n]; } const_reference at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } void reserve(size_type __n) { if (__n > max_size()) __throw_length_error(("vector::reserve")); if (capacity() < __n) _M_reallocate(__n); } reference front() { return *begin(); } const_reference front() const { return *begin(); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } void data() noexcept { } void push_back(bool __x) { if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) *this->_M_impl._M_finish++ = __x; else _M_insert_aux(end(), __x); } void swap(vector& __x) noexcept { std::swap(this->_M_impl._M_start, __x._M_impl._M_start); std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); std::swap(this->_M_impl._M_end_of_storage, __x._M_impl._M_end_of_storage); _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); } static void swap(reference __x, reference __y) noexcept { bool __tmp = __x; __x = __y; __y = __tmp; } iterator insert(const_iterator __position, const bool& __x = bool()) { const difference_type __n = __position - begin(); if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr() && __position == end()) *this->_M_impl._M_finish++ = __x; else _M_insert_aux(__position._M_const_cast(), __x); return begin() + __n; } template> iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { difference_type __offset = __position - cbegin(); _M_insert_dispatch(__position._M_const_cast(), __first, __last, __false_type()); return begin() + __offset; } # 1044 "/usr/include/c++/10/bits/stl_bvector.h" 3 iterator insert(const_iterator __position, size_type __n, const bool& __x) { difference_type __offset = __position - cbegin(); _M_fill_insert(__position._M_const_cast(), __n, __x); return begin() + __offset; } iterator insert(const_iterator __p, initializer_list __l) { return this->insert(__p, __l.begin(), __l.end()); } void pop_back() { --this->_M_impl._M_finish; } iterator erase(const_iterator __position) { return _M_erase(__position._M_const_cast()); } iterator erase(const_iterator __first, const_iterator __last) { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } void resize(size_type __new_size, bool __x = bool()) { if (__new_size < size()) _M_erase_at_end(begin() + difference_type(__new_size)); else insert(end(), __new_size - size(), __x); } void shrink_to_fit() { _M_shrink_to_fit(); } void flip() noexcept { _Bit_type * const __end = this->_M_impl._M_end_addr(); for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p) *__p = ~*__p; } void clear() noexcept { _M_erase_at_end(begin()); } template reference emplace_back(_Args&&... __args) { push_back(bool(__args...)); return back(); } template iterator emplace(const_iterator __pos, _Args&&... __args) { return insert(__pos, bool(__args...)); } protected: iterator _M_copy_aligned(const_iterator __first, const_iterator __last, iterator __result) { _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); return std::copy(const_iterator(__last._M_p, 0), __last, iterator(__q, 0)); } void _M_initialize(size_type __n) { if (__n) { _Bit_pointer __q = this->_M_allocate(__n); this->_M_impl._M_end_of_storage = __q + _S_nword(__n); this->_M_impl._M_start = iterator(std::__addressof(*__q), 0); } else { this->_M_impl._M_end_of_storage = _Bit_pointer(); this->_M_impl._M_start = iterator(0, 0); } this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n); } void _M_initialize_value(bool __x) { if (_Bit_type* __p = this->_M_impl._M_start._M_p) __builtin_memset(__p, __x ? ~0 : 0, (this->_M_impl._M_end_addr() - __p) * sizeof(_Bit_type)); } void _M_reallocate(size_type __n); bool _M_shrink_to_fit(); template void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) { _M_initialize(static_cast(__n)); _M_initialize_value(__x); } template void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { _M_initialize_range(__first, __last, std::__iterator_category(__first)); } template void _M_initialize_range(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) push_back(*__first); } template void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); _M_initialize(__n); std::copy(__first, __last, this->_M_impl._M_start); } # 1230 "/usr/include/c++/10/bits/stl_bvector.h" 3 void _M_fill_assign(size_t __n, bool __x) { if (__n > size()) { _M_initialize_value(__x); insert(end(), __n - size(), __x); } else { _M_erase_at_end(begin() + __n); _M_initialize_value(__x); } } template void _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { iterator __cur = begin(); for (; __first != __last && __cur != end(); ++__cur, (void)++__first) *__cur = *__first; if (__first == __last) _M_erase_at_end(__cur); else insert(end(), __first, __last); } template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __len = std::distance(__first, __last); if (__len < size()) _M_erase_at_end(std::copy(__first, __last, begin())); else { _ForwardIterator __mid = __first; std::advance(__mid, size()); std::copy(__first, __mid, begin()); insert(end(), __mid, __last); } } template void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, __true_type) { _M_fill_insert(__pos, __n, __x); } template void _M_insert_dispatch(iterator __pos, _InputIterator __first, _InputIterator __last, __false_type) { _M_insert_range(__pos, __first, __last, std::__iterator_category(__first)); } void _M_fill_insert(iterator __position, size_type __n, bool __x); template void _M_insert_range(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) { __pos = insert(__pos, *__first); ++__pos; } } template void _M_insert_range(iterator __position, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); void _M_insert_aux(iterator __position, bool __x); size_type _M_check_len(size_type __n, const char* __s) const { if (max_size() - size() < __n) __throw_length_error((__s)); const size_type __len = size() + std::max(size(), __n); return (__len < size() || __len > max_size()) ? max_size() : __len; } void _M_erase_at_end(iterator __pos) { this->_M_impl._M_finish = __pos; } iterator _M_erase(iterator __pos); iterator _M_erase(iterator __first, iterator __last); }; } namespace std __attribute__ ((__visibility__ ("default"))) { template struct hash> : public __hash_base> { size_t operator()(const std::vector&) const noexcept; }; } # 69 "/usr/include/c++/10/vector" 2 3 # 1 "/usr/include/c++/10/bits/vector.tcc" 1 3 # 59 "/usr/include/c++/10/bits/vector.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template void vector<_Tp, _Alloc>:: reserve(size_type __n) { if (__n > this->max_size()) __throw_length_error(("vector::reserve")); if (this->capacity() < __n) { const size_type __old_size = size(); pointer __tmp; if constexpr (_S_use_relocate()) { __tmp = this->_M_allocate(__n); _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, __tmp, _M_get_Tp_allocator()); } else { __tmp = _M_allocate_and_copy(__n, std::__make_move_if_noexcept_iterator(this->_M_impl._M_start), std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish)); std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); } ; _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __tmp; this->_M_impl._M_finish = __tmp + __old_size; this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; } } template template typename vector<_Tp, _Alloc>::reference vector<_Tp, _Alloc>:: emplace_back(_Args&&... __args) { if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::forward<_Args>(__args)...); ++this->_M_impl._M_finish; ; } else _M_realloc_insert(end(), std::forward<_Args>(__args)...); return back(); } template typename vector<_Tp, _Alloc>::iterator vector<_Tp, _Alloc>:: insert(const_iterator __position, const value_type& __x) { const size_type __n = __position - begin(); if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) if (__position == end()) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x); ++this->_M_impl._M_finish; ; } else { const auto __pos = begin() + (__position - cbegin()); _Temporary_value __x_copy(this, __x); _M_insert_aux(__pos, std::move(__x_copy._M_val())); } else _M_realloc_insert(begin() + (__position - cbegin()), __x); return iterator(this->_M_impl._M_start + __n); } template typename vector<_Tp, _Alloc>::iterator vector<_Tp, _Alloc>:: _M_erase(iterator __position) { if (__position + 1 != end()) std::move(__position + 1, end(), __position); --this->_M_impl._M_finish; _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); ; return __position; } template typename vector<_Tp, _Alloc>::iterator vector<_Tp, _Alloc>:: _M_erase(iterator __first, iterator __last) { if (__first != __last) { if (__last != end()) std::move(__last, end(), __first); _M_erase_at_end(__first.base() + (end() - __last)); } return __first; } template vector<_Tp, _Alloc>& vector<_Tp, _Alloc>:: operator=(const vector<_Tp, _Alloc>& __x) { if (&__x != this) { ; if (_Alloc_traits::_S_propagate_on_copy_assign()) { if (!_Alloc_traits::_S_always_equal() && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) { this->clear(); _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = nullptr; this->_M_impl._M_finish = nullptr; this->_M_impl._M_end_of_storage = nullptr; } std::__alloc_on_copy(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } const size_type __xlen = __x.size(); if (__xlen > capacity()) { pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end()); std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __tmp; this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; } else if (size() >= __xlen) { std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), end(), _M_get_Tp_allocator()); } else { std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), this->_M_impl._M_start); std::__uninitialized_copy_a(__x._M_impl._M_start + size(), __x._M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); } this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; } return *this; } template void vector<_Tp, _Alloc>:: _M_fill_assign(size_t __n, const value_type& __val) { if (__n > capacity()) { vector __tmp(__n, __val, _M_get_Tp_allocator()); __tmp._M_impl._M_swap_data(this->_M_impl); } else if (__n > size()) { std::fill(begin(), end(), __val); const size_type __add = __n - size(); ; this->_M_impl._M_finish = std::__uninitialized_fill_n_a(this->_M_impl._M_finish, __add, __val, _M_get_Tp_allocator()); ; } else _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); } template template void vector<_Tp, _Alloc>:: _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { pointer __cur(this->_M_impl._M_start); for (; __first != __last && __cur != this->_M_impl._M_finish; ++__cur, (void)++__first) *__cur = *__first; if (__first == __last) _M_erase_at_end(__cur); else _M_range_insert(end(), __first, __last, std::__iterator_category(__first)); } template template void vector<_Tp, _Alloc>:: _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __len = std::distance(__first, __last); if (__len > capacity()) { _S_check_init_len(__len, _M_get_Tp_allocator()); pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __tmp; this->_M_impl._M_finish = this->_M_impl._M_start + __len; this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; } else if (size() >= __len) _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); else { _ForwardIterator __mid = __first; std::advance(__mid, size()); std::copy(__first, __mid, this->_M_impl._M_start); const size_type __attribute__((__unused__)) __n = __len - size(); ; this->_M_impl._M_finish = std::__uninitialized_copy_a(__mid, __last, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; } } template auto vector<_Tp, _Alloc>:: _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator { const auto __n = __position - cbegin(); if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) if (__position == cend()) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::move(__v)); ++this->_M_impl._M_finish; ; } else _M_insert_aux(begin() + __n, std::move(__v)); else _M_realloc_insert(begin() + __n, std::move(__v)); return iterator(this->_M_impl._M_start + __n); } template template auto vector<_Tp, _Alloc>:: _M_emplace_aux(const_iterator __position, _Args&&... __args) -> iterator { const auto __n = __position - cbegin(); if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) if (__position == cend()) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::forward<_Args>(__args)...); ++this->_M_impl._M_finish; ; } else { _Temporary_value __tmp(this, std::forward<_Args>(__args)...); _M_insert_aux(begin() + __n, std::move(__tmp._M_val())); } else _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...); return iterator(this->_M_impl._M_start + __n); } template template void vector<_Tp, _Alloc>:: _M_insert_aux(iterator __position, _Arg&& __arg) { ; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, std::move(*(this->_M_impl._M_finish - 1))); ++this->_M_impl._M_finish; ; std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1) ; *__position = std::forward<_Arg>(__arg); } template template void vector<_Tp, _Alloc>:: _M_realloc_insert(iterator __position, _Args&&... __args) { const size_type __len = _M_check_len(size_type(1), "vector::_M_realloc_insert"); pointer __old_start = this->_M_impl._M_start; pointer __old_finish = this->_M_impl._M_finish; const size_type __elems_before = __position - begin(); pointer __new_start(this->_M_allocate(__len)); pointer __new_finish(__new_start); try { _Alloc_traits::construct(this->_M_impl, __new_start + __elems_before, std::forward<_Args>(__args)...); __new_finish = pointer(); if constexpr (_S_use_relocate()) { __new_finish = _S_relocate(__old_start, __position.base(), __new_start, _M_get_Tp_allocator()); ++__new_finish; __new_finish = _S_relocate(__position.base(), __old_finish, __new_finish, _M_get_Tp_allocator()); } else { __new_finish = std::__uninitialized_move_if_noexcept_a (__old_start, __position.base(), __new_start, _M_get_Tp_allocator()); ++__new_finish; __new_finish = std::__uninitialized_move_if_noexcept_a (__position.base(), __old_finish, __new_finish, _M_get_Tp_allocator()); } } catch(...) { if (!__new_finish) _Alloc_traits::destroy(this->_M_impl, __new_start + __elems_before); else std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); _M_deallocate(__new_start, __len); throw; } if constexpr (!_S_use_relocate()) std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); ; _M_deallocate(__old_start, this->_M_impl._M_end_of_storage - __old_start); this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_finish; this->_M_impl._M_end_of_storage = __new_start + __len; } template void vector<_Tp, _Alloc>:: _M_fill_insert(iterator __position, size_type __n, const value_type& __x) { if (__n != 0) { if (size_type(this->_M_impl._M_end_of_storage - this->_M_impl._M_finish) >= __n) { _Temporary_value __tmp(this, __x); value_type& __x_copy = __tmp._M_val(); const size_type __elems_after = end() - __position; pointer __old_finish(this->_M_impl._M_finish); if (__elems_after > __n) { ; std::__uninitialized_move_a(this->_M_impl._M_finish - __n, this->_M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __n; ; std::move_backward(__position.base(), __old_finish - __n, __old_finish) ; std::fill(__position.base(), __position.base() + __n, __x_copy); } else { ; this->_M_impl._M_finish = std::__uninitialized_fill_n_a(this->_M_impl._M_finish, __n - __elems_after, __x_copy, _M_get_Tp_allocator()); ; std::__uninitialized_move_a(__position.base(), __old_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __elems_after; ; std::fill(__position.base(), __old_finish, __x_copy); } } else { const size_type __len = _M_check_len(__n, "vector::_M_fill_insert"); const size_type __elems_before = __position - begin(); pointer __new_start(this->_M_allocate(__len)); pointer __new_finish(__new_start); try { std::__uninitialized_fill_n_a(__new_start + __elems_before, __n, __x, _M_get_Tp_allocator()); __new_finish = pointer(); __new_finish = std::__uninitialized_move_if_noexcept_a (this->_M_impl._M_start, __position.base(), __new_start, _M_get_Tp_allocator()); __new_finish += __n; __new_finish = std::__uninitialized_move_if_noexcept_a (__position.base(), this->_M_impl._M_finish, __new_finish, _M_get_Tp_allocator()); } catch(...) { if (!__new_finish) std::_Destroy(__new_start + __elems_before, __new_start + __elems_before + __n, _M_get_Tp_allocator()); else std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); _M_deallocate(__new_start, __len); throw; } std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_finish; this->_M_impl._M_end_of_storage = __new_start + __len; } } } template void vector<_Tp, _Alloc>:: _M_default_append(size_type __n) { if (__n != 0) { const size_type __size = size(); size_type __navail = size_type(this->_M_impl._M_end_of_storage - this->_M_impl._M_finish); if (__size > max_size() || __navail > max_size() - __size) __builtin_unreachable(); if (__navail >= __n) { ; this->_M_impl._M_finish = std::__uninitialized_default_n_a(this->_M_impl._M_finish, __n, _M_get_Tp_allocator()); ; } else { const size_type __len = _M_check_len(__n, "vector::_M_default_append"); pointer __new_start(this->_M_allocate(__len)); if constexpr (_S_use_relocate()) { try { std::__uninitialized_default_n_a(__new_start + __size, __n, _M_get_Tp_allocator()); } catch(...) { _M_deallocate(__new_start, __len); throw; } _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, __new_start, _M_get_Tp_allocator()); } else { pointer __destroy_from = pointer(); try { std::__uninitialized_default_n_a(__new_start + __size, __n, _M_get_Tp_allocator()); __destroy_from = __new_start + __size; std::__uninitialized_move_if_noexcept_a( this->_M_impl._M_start, this->_M_impl._M_finish, __new_start, _M_get_Tp_allocator()); } catch(...) { if (__destroy_from) std::_Destroy(__destroy_from, __destroy_from + __n, _M_get_Tp_allocator()); _M_deallocate(__new_start, __len); throw; } std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); } ; _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_start + __size + __n; this->_M_impl._M_end_of_storage = __new_start + __len; } } } template bool vector<_Tp, _Alloc>:: _M_shrink_to_fit() { if (capacity() == size()) return false; ; return std::__shrink_to_fit_aux::_S_do_it(*this); } template template void vector<_Tp, _Alloc>:: _M_range_insert(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag) { if (__pos == end()) { for (; __first != __last; ++__first) insert(end(), *__first); } else if (__first != __last) { vector __tmp(__first, __last, _M_get_Tp_allocator()); insert(__pos, std::make_move_iterator(__tmp.begin()), std::make_move_iterator(__tmp.end())); } } template template void vector<_Tp, _Alloc>:: _M_range_insert(iterator __position, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { if (__first != __last) { const size_type __n = std::distance(__first, __last); if (size_type(this->_M_impl._M_end_of_storage - this->_M_impl._M_finish) >= __n) { const size_type __elems_after = end() - __position; pointer __old_finish(this->_M_impl._M_finish); if (__elems_after > __n) { ; std::__uninitialized_move_a(this->_M_impl._M_finish - __n, this->_M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __n; ; std::move_backward(__position.base(), __old_finish - __n, __old_finish) ; std::copy(__first, __last, __position); } else { _ForwardIterator __mid = __first; std::advance(__mid, __elems_after); ; std::__uninitialized_copy_a(__mid, __last, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __n - __elems_after; ; std::__uninitialized_move_a(__position.base(), __old_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish += __elems_after; ; std::copy(__first, __mid, __position); } } else { const size_type __len = _M_check_len(__n, "vector::_M_range_insert"); pointer __new_start(this->_M_allocate(__len)); pointer __new_finish(__new_start); try { __new_finish = std::__uninitialized_move_if_noexcept_a (this->_M_impl._M_start, __position.base(), __new_start, _M_get_Tp_allocator()); __new_finish = std::__uninitialized_copy_a(__first, __last, __new_finish, _M_get_Tp_allocator()); __new_finish = std::__uninitialized_move_if_noexcept_a (__position.base(), this->_M_impl._M_finish, __new_finish, _M_get_Tp_allocator()); } catch(...) { std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); _M_deallocate(__new_start, __len); throw; } std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, _M_get_Tp_allocator()); ; _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage - this->_M_impl._M_start); this->_M_impl._M_start = __new_start; this->_M_impl._M_finish = __new_finish; this->_M_impl._M_end_of_storage = __new_start + __len; } } } template void vector:: _M_reallocate(size_type __n) { _Bit_pointer __q = this->_M_allocate(__n); iterator __start(std::__addressof(*__q), 0); iterator __finish(_M_copy_aligned(begin(), end(), __start)); this->_M_deallocate(); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; this->_M_impl._M_end_of_storage = __q + _S_nword(__n); } template void vector:: _M_fill_insert(iterator __position, size_type __n, bool __x) { if (__n == 0) return; if (capacity() - size() >= __n) { std::copy_backward(__position, end(), this->_M_impl._M_finish + difference_type(__n)); std::fill(__position, __position + difference_type(__n), __x); this->_M_impl._M_finish += difference_type(__n); } else { const size_type __len = _M_check_len(__n, "vector::_M_fill_insert"); _Bit_pointer __q = this->_M_allocate(__len); iterator __start(std::__addressof(*__q), 0); iterator __i = _M_copy_aligned(begin(), __position, __start); std::fill(__i, __i + difference_type(__n), __x); iterator __finish = std::copy(__position, end(), __i + difference_type(__n)); this->_M_deallocate(); this->_M_impl._M_end_of_storage = __q + _S_nword(__len); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; } } template template void vector:: _M_insert_range(iterator __position, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { if (__first != __last) { size_type __n = std::distance(__first, __last); if (capacity() - size() >= __n) { std::copy_backward(__position, end(), this->_M_impl._M_finish + difference_type(__n)); std::copy(__first, __last, __position); this->_M_impl._M_finish += difference_type(__n); } else { const size_type __len = _M_check_len(__n, "vector::_M_insert_range"); _Bit_pointer __q = this->_M_allocate(__len); iterator __start(std::__addressof(*__q), 0); iterator __i = _M_copy_aligned(begin(), __position, __start); __i = std::copy(__first, __last, __i); iterator __finish = std::copy(__position, end(), __i); this->_M_deallocate(); this->_M_impl._M_end_of_storage = __q + _S_nword(__len); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; } } } template void vector:: _M_insert_aux(iterator __position, bool __x) { if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) { std::copy_backward(__position, this->_M_impl._M_finish, this->_M_impl._M_finish + 1); *__position = __x; ++this->_M_impl._M_finish; } else { const size_type __len = _M_check_len(size_type(1), "vector::_M_insert_aux"); _Bit_pointer __q = this->_M_allocate(__len); iterator __start(std::__addressof(*__q), 0); iterator __i = _M_copy_aligned(begin(), __position, __start); *__i++ = __x; iterator __finish = std::copy(__position, end(), __i); this->_M_deallocate(); this->_M_impl._M_end_of_storage = __q + _S_nword(__len); this->_M_impl._M_start = __start; this->_M_impl._M_finish = __finish; } } template typename vector::iterator vector:: _M_erase(iterator __position) { if (__position + 1 != end()) std::copy(__position + 1, end(), __position); --this->_M_impl._M_finish; return __position; } template typename vector::iterator vector:: _M_erase(iterator __first, iterator __last) { if (__first != __last) _M_erase_at_end(std::copy(__last, end(), __first)); return __first; } template bool vector:: _M_shrink_to_fit() { if (capacity() - size() < int(_S_word_bit)) return false; try { _M_reallocate(size()); return true; } catch(...) { return false; } } } namespace std __attribute__ ((__visibility__ ("default"))) { template size_t hash>:: operator()(const std::vector& __b) const noexcept { size_t __hash = 0; using std::_S_word_bit; using std::_Bit_type; const size_t __words = __b.size() / _S_word_bit; if (__words) { const size_t __clength = __words * sizeof(_Bit_type); __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); } const size_t __extrabits = __b.size() % _S_word_bit; if (__extrabits) { _Bit_type __hiword = *__b._M_impl._M_finish._M_p; __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); const size_t __clength = (__extrabits + 8 - 1) / 8; if (__words) __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); else __hash = std::_Hash_impl::hash(&__hiword, __clength); } return __hash; } } # 73 "/usr/include/c++/10/vector" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename vector<_Tp, _Alloc>::size_type erase_if(vector<_Tp, _Alloc>& __cont, _Predicate __pred) { const auto __osz = __cont.size(); __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred), __cont.end()); return __osz - __cont.size(); } template inline typename vector<_Tp, _Alloc>::size_type erase(vector<_Tp, _Alloc>& __cont, const _Up& __value) { const auto __osz = __cont.size(); __cont.erase(std::remove(__cont.begin(), __cont.end(), __value), __cont.end()); return __osz - __cont.size(); } } # 63 "/usr/include/c++/10/functional" 2 3 # 72 "/usr/include/c++/10/functional" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 83 "/usr/include/c++/10/functional" 3 template inline constexpr invoke_result_t<_Callable, _Args...> invoke(_Callable&& __fn, _Args&&... __args) noexcept(is_nothrow_invocable_v<_Callable, _Args...>) { return std::__invoke(std::forward<_Callable>(__fn), std::forward<_Args>(__args)...); } template::value> class _Mem_fn_base : public _Mem_fn_traits<_MemFunPtr>::__maybe_type { using _Traits = _Mem_fn_traits<_MemFunPtr>; using _Arity = typename _Traits::__arity; using _Varargs = typename _Traits::__vararg; template friend struct _Bind_check_arity; _MemFunPtr _M_pmf; public: using result_type = typename _Traits::__result_type; explicit constexpr _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { } template constexpr auto operator()(_Args&&... __args) const noexcept(noexcept( std::__invoke(_M_pmf, std::forward<_Args>(__args)...))) -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...)) { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); } }; template class _Mem_fn_base<_MemObjPtr, false> { using _Arity = integral_constant; using _Varargs = false_type; template friend struct _Bind_check_arity; _MemObjPtr _M_pm; public: explicit constexpr _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { } template constexpr auto operator()(_Tp&& __obj) const noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))) -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj))) { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); } }; template struct _Mem_fn; template struct _Mem_fn<_Res _Class::*> : _Mem_fn_base<_Res _Class::*> { using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base; }; # 167 "/usr/include/c++/10/functional" 3 template constexpr inline _Mem_fn<_Tp _Class::*> mem_fn(_Tp _Class::* __pm) noexcept { return _Mem_fn<_Tp _Class::*>(__pm); } # 183 "/usr/include/c++/10/functional" 3 template struct is_bind_expression : public false_type { }; # 194 "/usr/include/c++/10/functional" 3 template struct is_placeholder : public integral_constant { }; template inline constexpr bool is_bind_expression_v = is_bind_expression<_Tp>::value; template inline constexpr int is_placeholder_v = is_placeholder<_Tp>::value; template struct _Placeholder { }; namespace placeholders { extern const _Placeholder<1> _1; extern const _Placeholder<2> _2; extern const _Placeholder<3> _3; extern const _Placeholder<4> _4; extern const _Placeholder<5> _5; extern const _Placeholder<6> _6; extern const _Placeholder<7> _7; extern const _Placeholder<8> _8; extern const _Placeholder<9> _9; extern const _Placeholder<10> _10; extern const _Placeholder<11> _11; extern const _Placeholder<12> _12; extern const _Placeholder<13> _13; extern const _Placeholder<14> _14; extern const _Placeholder<15> _15; extern const _Placeholder<16> _16; extern const _Placeholder<17> _17; extern const _Placeholder<18> _18; extern const _Placeholder<19> _19; extern const _Placeholder<20> _20; extern const _Placeholder<21> _21; extern const _Placeholder<22> _22; extern const _Placeholder<23> _23; extern const _Placeholder<24> _24; extern const _Placeholder<25> _25; extern const _Placeholder<26> _26; extern const _Placeholder<27> _27; extern const _Placeholder<28> _28; extern const _Placeholder<29> _29; } template struct is_placeholder<_Placeholder<_Num> > : public integral_constant { }; template struct is_placeholder > : public integral_constant { }; template using _Safe_tuple_element_t = typename enable_if<(__i < tuple_size<_Tuple>::value), tuple_element<__i, _Tuple>>::type::type; # 285 "/usr/include/c++/10/functional" 3 template::value, bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)> class _Mu; template class _Mu, false, false> { public: template constexpr _Tp& operator()(_CVRef& __arg, _Tuple&) const volatile { return __arg.get(); } }; template class _Mu<_Arg, true, false> { public: template constexpr auto operator()(_CVArg& __arg, tuple<_Args...>& __tuple) const volatile -> decltype(__arg(declval<_Args>()...)) { typedef typename _Build_index_tuple::__type _Indexes; return this->__call(__arg, __tuple, _Indexes()); } private: template constexpr auto __call(_CVArg& __arg, tuple<_Args...>& __tuple, const _Index_tuple<_Indexes...>&) const volatile -> decltype(__arg(declval<_Args>()...)) { return __arg(std::get<_Indexes>(std::move(__tuple))...); } }; template class _Mu<_Arg, false, true> { public: template constexpr _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&& operator()(const volatile _Arg&, _Tuple& __tuple) const volatile { return ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple)); } }; template class _Mu<_Arg, false, false> { public: template constexpr _CVArg&& operator()(_CVArg&& __arg, _Tuple&) const volatile { return std::forward<_CVArg>(__arg); } }; template inline auto __volget(volatile tuple<_Tp...>& __tuple) -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile& { return std::get<_Ind>(const_cast&>(__tuple)); } template inline auto __volget(const volatile tuple<_Tp...>& __tuple) -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile& { return std::get<_Ind>(const_cast&>(__tuple)); } template struct _Bind; template class _Bind<_Functor(_Bound_args...)> : public _Weak_result_type<_Functor> { typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; template constexpr _Result __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) { return std::__invoke(_M_f, _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)... ); } template constexpr _Result __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const { return std::__invoke(_M_f, _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)... ); } template _Result __call_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile { return std::__invoke(_M_f, _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)... ); } template _Result __call_c_v(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile { return std::__invoke(_M_f, _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)... ); } template using _Mu_type = decltype( _Mu::type>()( std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) ); template using _Res_type_impl = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type; template using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>; template using __dependent = typename enable_if::value+1), _Functor>::type; template class __cv_quals> using _Res_type_cv = _Res_type_impl< typename __cv_quals<__dependent<_CallArgs>>::type, _CallArgs, typename __cv_quals<_Bound_args>::type...>; public: template explicit constexpr _Bind(const _Functor& __f, _Args&&... __args) : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) { } template explicit constexpr _Bind(_Functor&& __f, _Args&&... __args) : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) { } _Bind(const _Bind&) = default; _Bind(_Bind&&) = default; template>> constexpr _Result operator()(_Args&&... __args) { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template, add_const>> constexpr _Result operator()(_Args&&... __args) const { return this->__call_c<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } # 523 "/usr/include/c++/10/functional" 3 template, add_volatile>> [[deprecated("std::bind does not support volatile in C++17")]] _Result operator()(_Args&&... __args) volatile { return this->__call_v<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template, add_cv>> [[deprecated("std::bind does not support volatile in C++17")]] _Result operator()(_Args&&... __args) const volatile { return this->__call_c_v<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } }; template struct _Bind_result; template class _Bind_result<_Result, _Functor(_Bound_args...)> { typedef typename _Build_index_tuple::__type _Bound_indexes; _Functor _M_f; tuple<_Bound_args...> _M_bound_args; template constexpr _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } template constexpr _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (std::get<_Indexes>(_M_bound_args), __args)...); } template constexpr _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } template constexpr _Res __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const volatile { return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>() (__volget<_Indexes>(_M_bound_args), __args)...); } public: typedef _Result result_type; template explicit constexpr _Bind_result(const _Functor& __f, _Args&&... __args) : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...) { } template explicit constexpr _Bind_result(_Functor&& __f, _Args&&... __args) : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...) { } _Bind_result(const _Bind_result&) = default; _Bind_result(_Bind_result&&) = default; template constexpr result_type operator()(_Args&&... __args) { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template constexpr result_type operator()(_Args&&... __args) const { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template [[deprecated("std::bind does not support volatile in C++17")]] result_type operator()(_Args&&... __args) volatile { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } template [[deprecated("std::bind does not support volatile in C++17")]] result_type operator()(_Args&&... __args) const volatile { return this->__call<_Result>( std::forward_as_tuple(std::forward<_Args>(__args)...), _Bound_indexes()); } }; template struct is_bind_expression<_Bind<_Signature> > : public true_type { }; template struct is_bind_expression > : public true_type { }; template struct is_bind_expression > : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct is_bind_expression<_Bind_result<_Result, _Signature>> : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct is_bind_expression> : public true_type { }; template struct _Bind_check_arity { }; template struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...> { static_assert(sizeof...(_BoundArgs) == sizeof...(_Args), "Wrong number of arguments for function"); }; template struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...> { static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args), "Wrong number of arguments for function"); }; template struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...> { using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity; using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs; static_assert(_Varargs::value ? sizeof...(_BoundArgs) >= _Arity::value + 1 : sizeof...(_BoundArgs) == _Arity::value + 1, "Wrong number of arguments for pointer-to-member"); }; template::type> using __is_socketlike = __or_, is_enum<_Tp2>>; template struct _Bind_helper : _Bind_check_arity::type, _BoundArgs...> { typedef typename decay<_Func>::type __func_type; typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type; }; template struct _Bind_helper { }; template inline constexpr typename _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type bind(_Func&& __f, _BoundArgs&&... __args) { typedef _Bind_helper __helper_type; return typename __helper_type::type(std::forward<_Func>(__f), std::forward<_BoundArgs>(__args)...); } template struct _Bindres_helper : _Bind_check_arity::type, _BoundArgs...> { typedef typename decay<_Func>::type __functor_type; typedef _Bind_result<_Result, __functor_type(typename decay<_BoundArgs>::type...)> type; }; template inline constexpr typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type bind(_Func&& __f, _BoundArgs&&... __args) { typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type; return typename __helper_type::type(std::forward<_Func>(__f), std::forward<_BoundArgs>(__args)...); } template struct _Bind_front { static_assert(is_move_constructible_v<_Fd>); static_assert((is_move_constructible_v<_BoundArgs> && ...)); template explicit constexpr _Bind_front(int, _Fn&& __fn, _Args&&... __args) noexcept(__and_, is_nothrow_constructible<_BoundArgs, _Args>...>::value) : _M_fd(std::forward<_Fn>(__fn)), _M_bound_args(std::forward<_Args>(__args)...) { static_assert(sizeof...(_Args) == sizeof...(_BoundArgs)); } _Bind_front(const _Bind_front&) = default; _Bind_front(_Bind_front&&) = default; _Bind_front& operator=(const _Bind_front&) = default; _Bind_front& operator=(_Bind_front&&) = default; ~_Bind_front() = default; template constexpr invoke_result_t<_Fd&, _BoundArgs&..., _CallArgs...> operator()(_CallArgs&&... __call_args) & noexcept(is_nothrow_invocable_v<_Fd&, _BoundArgs&..., _CallArgs...>) { return _S_call(*this, _BoundIndices(), std::forward<_CallArgs>(__call_args)...); } template constexpr invoke_result_t operator()(_CallArgs&&... __call_args) const & noexcept(is_nothrow_invocable_v) { return _S_call(*this, _BoundIndices(), std::forward<_CallArgs>(__call_args)...); } template constexpr invoke_result_t<_Fd, _BoundArgs..., _CallArgs...> operator()(_CallArgs&&... __call_args) && noexcept(is_nothrow_invocable_v<_Fd, _BoundArgs..., _CallArgs...>) { return _S_call(std::move(*this), _BoundIndices(), std::forward<_CallArgs>(__call_args)...); } template constexpr invoke_result_t operator()(_CallArgs&&... __call_args) const && noexcept(is_nothrow_invocable_v) { return _S_call(std::move(*this), _BoundIndices(), std::forward<_CallArgs>(__call_args)...); } private: using _BoundIndices = index_sequence_for<_BoundArgs...>; template static constexpr decltype(auto) _S_call(_Tp&& __g, index_sequence<_Ind...>, _CallArgs&&... __call_args) { return std::invoke(std::forward<_Tp>(__g)._M_fd, std::get<_Ind>(std::forward<_Tp>(__g)._M_bound_args)..., std::forward<_CallArgs>(__call_args)...); } _Fd _M_fd; std::tuple<_BoundArgs...> _M_bound_args; }; template using _Bind_front_t = _Bind_front, decay_t<_Args>...>; template constexpr _Bind_front_t<_Fn, _Args...> bind_front(_Fn&& __fn, _Args&&... __args) noexcept(is_nothrow_constructible_v<_Bind_front_t<_Fn, _Args...>, int, _Fn, _Args...>) { return _Bind_front_t<_Fn, _Args...>(0, std::forward<_Fn>(__fn), std::forward<_Args>(__args)...); } template class _Not_fn { template using __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type; template static decltype(!std::declval<_Tp>()) _S_not() noexcept(noexcept(!std::declval<_Tp>())); public: template constexpr _Not_fn(_Fn2&& __fn, int) : _M_fn(std::forward<_Fn2>(__fn)) { } _Not_fn(const _Not_fn& __fn) = default; _Not_fn(_Not_fn&& __fn) = default; ~_Not_fn() = default; # 952 "/usr/include/c++/10/functional" 3 template constexpr decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_Fn &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); } template constexpr decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(__is_nothrow_invocable<_Fn const &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); } template constexpr decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(__is_nothrow_invocable<_Fn &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); } template constexpr decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothrow_invocable<_Fn const &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); } private: _Fn _M_fn; }; template struct __is_byte_like : false_type { }; template struct __is_byte_like<_Tp, equal_to<_Tp>> : __bool_constant::value> { }; template struct __is_byte_like<_Tp, equal_to> : __bool_constant::value> { }; enum class byte : unsigned char; template<> struct __is_byte_like> : true_type { }; template<> struct __is_byte_like> : true_type { }; template constexpr inline auto not_fn(_Fn&& __fn) noexcept(std::is_nothrow_constructible, _Fn&&>::value) { return _Not_fn>{std::forward<_Fn>(__fn), 0}; } template> class default_searcher { public: constexpr default_searcher(_ForwardIterator1 __pat_first, _ForwardIterator1 __pat_last, _BinaryPredicate __pred = _BinaryPredicate()) : _M_m(__pat_first, __pat_last, std::move(__pred)) { } template constexpr pair<_ForwardIterator2, _ForwardIterator2> operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const { _ForwardIterator2 __first_ret = std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m), std::get<2>(_M_m)); auto __ret = std::make_pair(__first_ret, __first_ret); if (__ret.first != __last) std::advance(__ret.second, std::distance(std::get<0>(_M_m), std::get<1>(_M_m))); return __ret; } private: tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m; }; template struct __boyer_moore_map_base { template __boyer_moore_map_base(_RAIter __pat, size_t __patlen, _Hash&& __hf, _Pred&& __pred) : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) } { if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) _M_bad_char[__pat[__i]] = __patlen - 1 - __i; } using __diff_type = _Tp; __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __iter = _M_bad_char.find(__key); if (__iter == _M_bad_char.end()) return __not_found; return __iter->second; } _Pred _M_pred() const { return _M_bad_char.key_eq(); } std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char; }; template struct __boyer_moore_array_base { template __boyer_moore_array_base(_RAIter __pat, size_t __patlen, _Unused&&, _Pred&& __pred) : _M_bad_char{ std::array<_Tp, _Len>{}, std::move(__pred) } { std::get<0>(_M_bad_char).fill(__patlen); if (__patlen > 0) for (__diff_type __i = 0; __i < __patlen - 1; ++__i) { auto __ch = __pat[__i]; using _UCh = make_unsigned_t; auto __uch = static_cast<_UCh>(__ch); std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i; } } using __diff_type = _Tp; template __diff_type _M_lookup(_Key __key, __diff_type __not_found) const { auto __ukey = static_cast>(__key); if (__ukey >= _Len) return __not_found; return std::get<0>(_M_bad_char)[__ukey]; } const _Pred& _M_pred() const { return std::get<1>(_M_bad_char); } tuple, _Pred> _M_bad_char; }; template::value_type, typename _Diff = typename iterator_traits<_RAIter>::difference_type> using __boyer_moore_base_t = conditional_t<__is_byte_like<_Val, _Pred>::value, __boyer_moore_array_base<_Diff, 256, _Pred>, __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>; template::value_type>, typename _BinaryPredicate = equal_to<>> class boyer_moore_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()); template pair<_RandomAccessIterator2, _RandomAccessIterator2> operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const; private: bool _M_is_prefix(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __suffixlen = __len - __pos; for (__diff_type __i = 0; __i < __suffixlen; ++__i) if (!__pred(__word[__i], __word[__pos + __i])) return false; return true; } __diff_type _M_suffix_length(_RAIter __word, __diff_type __len, __diff_type __pos) { const auto& __pred = this->_M_pred(); __diff_type __i = 0; while (__pred(__word[__pos - __i], __word[__len - 1 - __i]) && __i < __pos) { ++__i; } return __i; } template __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; std::vector<__diff_type> _M_good_suffix; }; template::value_type>, typename _BinaryPredicate = equal_to<>> class boyer_moore_horspool_searcher : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate> { using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>; using typename _Base::__diff_type; public: boyer_moore_horspool_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf = _Hash(), _BinaryPredicate __pred = _BinaryPredicate()) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end) { } template pair<_RandomAccessIterator2, _RandomAccessIterator2> operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { const auto& __pred = this->_M_pred(); auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return std::make_pair(__first, __first); auto __len = __last - __first; while (__len >= __patlen) { for (auto __scan = __patlen - 1; __pred(__first[__scan], _M_pat[__scan]); --__scan) if (__scan == 0) return std::make_pair(__first, __first + __patlen); auto __shift = _M_bad_char_shift(__first[__patlen - 1]); __len -= __shift; __first += __shift; } return std::make_pair(__last, __last); } private: template __diff_type _M_bad_char_shift(_Tp __c) const { return this->_M_lookup(__c, _M_pat_end - _M_pat); } _RAIter _M_pat; _RAIter _M_pat_end; }; template boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end, _Hash __hf, _BinaryPredicate __pred) : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)), _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat) { auto __patlen = __pat_end - __pat; if (__patlen == 0) return; __diff_type __last_prefix = __patlen - 1; for (__diff_type __p = __patlen - 1; __p >= 0; --__p) { if (_M_is_prefix(__pat, __patlen, __p + 1)) __last_prefix = __p + 1; _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p); } for (__diff_type __p = 0; __p < __patlen - 1; ++__p) { auto __slen = _M_suffix_length(__pat, __patlen, __p); auto __pos = __patlen - 1 - __slen; if (!__pred(__pat[__p - __slen], __pat[__pos])) _M_good_suffix[__pos] = __patlen - 1 - __p + __slen; } } template template pair<_RandomAccessIterator2, _RandomAccessIterator2> boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>:: operator()(_RandomAccessIterator2 __first, _RandomAccessIterator2 __last) const { auto __patlen = _M_pat_end - _M_pat; if (__patlen == 0) return std::make_pair(__first, __first); const auto& __pred = this->_M_pred(); __diff_type __i = __patlen - 1; auto __stringlen = __last - __first; while (__i < __stringlen) { __diff_type __j = __patlen - 1; while (__j >= 0 && __pred(__first[__i], _M_pat[__j])) { --__i; --__j; } if (__j < 0) { const auto __match = __first + __i + 1; return std::make_pair(__match, __match + __patlen); } __i += std::max(_M_bad_char_shift(__first[__i]), _M_good_suffix[__j]); } return std::make_pair(__last, __last); } } # 22 "all-std.cxx" 2 # 1 "/usr/include/c++/10/typeindex" 1 3 # 32 "/usr/include/c++/10/typeindex" 3 # 33 "/usr/include/c++/10/typeindex" 3 # 43 "/usr/include/c++/10/typeindex" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 55 "/usr/include/c++/10/typeindex" 3 struct type_index { type_index(const type_info& __rhs) noexcept : _M_target(&__rhs) { } bool operator==(const type_index& __rhs) const noexcept { return *_M_target == *__rhs._M_target; } bool operator<(const type_index& __rhs) const noexcept { return _M_target->before(*__rhs._M_target); } bool operator<=(const type_index& __rhs) const noexcept { return !__rhs._M_target->before(*_M_target); } bool operator>(const type_index& __rhs) const noexcept { return __rhs._M_target->before(*_M_target); } bool operator>=(const type_index& __rhs) const noexcept { return !_M_target->before(*__rhs._M_target); } strong_ordering operator<=>(const type_index& __rhs) const noexcept { if (*_M_target == *__rhs._M_target) return strong_ordering::equal; if (_M_target->before(*__rhs._M_target)) return strong_ordering::less; return strong_ordering::greater; } size_t hash_code() const noexcept { return _M_target->hash_code(); } const char* name() const noexcept { return _M_target->name(); } private: const type_info* _M_target; }; template struct hash; template<> struct hash { typedef size_t result_type; typedef type_index argument_type; size_t operator()(const type_index& __ti) const noexcept { return __ti.hash_code(); } }; } # 28 "all-std.cxx" 2 # 1 "/usr/include/c++/10/variant" 1 3 # 32 "/usr/include/c++/10/variant" 3 # 33 "/usr/include/c++/10/variant" 3 # 52 "/usr/include/c++/10/variant" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { namespace __variant { template struct _Nth_type; template struct _Nth_type<_Np, _First, _Rest...> : _Nth_type<_Np-1, _Rest...> { }; template struct _Nth_type<0, _First, _Rest...> { using type = _First; }; } } template class tuple; template class variant; template struct hash; template struct variant_size; template struct variant_size : variant_size<_Variant> {}; template struct variant_size : variant_size<_Variant> {}; template struct variant_size : variant_size<_Variant> {}; template struct variant_size> : std::integral_constant {}; template inline constexpr size_t variant_size_v = variant_size<_Variant>::value; template struct variant_alternative; template struct variant_alternative<_Np, variant<_First, _Rest...>> : variant_alternative<_Np-1, variant<_Rest...>> {}; template struct variant_alternative<0, variant<_First, _Rest...>> { using type = _First; }; template using variant_alternative_t = typename variant_alternative<_Np, _Variant>::type; template struct variant_alternative<_Np, const _Variant> { using type = add_const_t>; }; template struct variant_alternative<_Np, volatile _Variant> { using type = add_volatile_t>; }; template struct variant_alternative<_Np, const volatile _Variant> { using type = add_cv_t>; }; inline constexpr size_t variant_npos = -1; template constexpr variant_alternative_t<_Np, variant<_Types...>>& get(variant<_Types...>&); template constexpr variant_alternative_t<_Np, variant<_Types...>>&& get(variant<_Types...>&&); template constexpr variant_alternative_t<_Np, variant<_Types...>> const& get(const variant<_Types...>&); template constexpr variant_alternative_t<_Np, variant<_Types...>> const&& get(const variant<_Types...>&&); template constexpr decltype(auto) __do_visit(_Visitor&& __visitor, _Variants&&... __variants); template decltype(auto) __variant_cast(_Tp&& __rhs) { if constexpr (is_lvalue_reference_v<_Tp>) { if constexpr (is_const_v>) return static_cast&>(__rhs); else return static_cast&>(__rhs); } else return static_cast&&>(__rhs); } namespace __detail { namespace __variant { template struct __index_of : std::integral_constant {}; template inline constexpr size_t __index_of_v = __index_of<_Tp, _Types...>::value; template struct __index_of<_Tp, _First, _Rest...> : std::integral_constant ? 0 : __index_of_v<_Tp, _Rest...> + 1> {}; struct __variant_cookie {}; struct __variant_idx_cookie { using type = __variant_idx_cookie; }; template struct __deduce_visit_result { }; template constexpr void __raw_visit(_Visitor&& __visitor, _Variants&&... __variants) { std::__do_visit<__variant_cookie>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); } template constexpr void __raw_idx_visit(_Visitor&& __visitor, _Variants&&... __variants) { std::__do_visit<__variant_idx_cookie>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); } template> struct _Uninitialized; template struct _Uninitialized<_Type, true> { template 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 struct _Uninitialized<_Type, false> { template constexpr _Uninitialized(in_place_index_t<0>, _Args&&... __args) { ::new ((void*)std::addressof(_M_storage)) _Type(std::forward<_Args>(__args)...); } const _Type& _M_get() const & noexcept { return *_M_storage._M_ptr(); } _Type& _M_get() & noexcept { return *_M_storage._M_ptr(); } const _Type&& _M_get() const && noexcept { return std::move(*_M_storage._M_ptr()); } _Type&& _M_get() && noexcept { return std::move(*_M_storage._M_ptr()); } __gnu_cxx::__aligned_membuf<_Type> _M_storage; }; template constexpr decltype(auto) __get(in_place_index_t<0>, _Union&& __u) noexcept { return std::forward<_Union>(__u)._M_first._M_get(); } template constexpr decltype(auto) __get(in_place_index_t<_Np>, _Union&& __u) noexcept { return __variant::__get(in_place_index<_Np-1>, std::forward<_Union>(__u)._M_rest); } template constexpr decltype(auto) __get(_Variant&& __v) noexcept { return __variant::__get(std::in_place_index<_Np>, std::forward<_Variant>(__v)._M_u); } template struct _Traits { static constexpr bool _S_default_ctor = is_default_constructible_v::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 union _Variadic_union { }; template union _Variadic_union<_First, _Rest...> { constexpr _Variadic_union() : _M_rest() { } template constexpr _Variadic_union(in_place_index_t<0>, _Args&&... __args) : _M_first(in_place_index<0>, std::forward<_Args>(__args)...) { } template constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&... __args) : _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...) { } _Uninitialized<_First> _M_first; _Variadic_union<_Rest...> _M_rest; }; template struct _Never_valueless_alt : __and_, is_trivially_copyable<_Tp>> { }; # 368 "/usr/include/c++/10/variant" 3 template constexpr bool __never_valueless() { return _Traits<_Types...>::_S_move_assign && (_Never_valueless_alt<_Types>::value && ...); } template struct _Variant_storage; template using __select_index = typename __select_int::_Select_int_base::type::value_type; template struct _Variant_storage { constexpr _Variant_storage() : _M_index(static_cast<__index_type>(variant_npos)) { } template constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), _M_index{_Np} { } void _M_reset() { if (!_M_valid()) [[unlikely]] return; std::__do_visit([](auto&& __this_mem) mutable { std::_Destroy(std::__addressof(__this_mem)); }, __variant_cast<_Types...>(*this)); _M_index = static_cast<__index_type>(variant_npos); } ~_Variant_storage() { _M_reset(); } void* _M_storage() const noexcept { return const_cast(static_cast( std::addressof(_M_u))); } constexpr bool _M_valid() const noexcept { if constexpr (__variant::__never_valueless<_Types...>()) return true; return this->_M_index != __index_type(variant_npos); } _Variadic_union<_Types...> _M_u; using __index_type = __select_index<_Types...>; __index_type _M_index; }; template struct _Variant_storage { constexpr _Variant_storage() : _M_index(static_cast<__index_type>(variant_npos)) { } template constexpr _Variant_storage(in_place_index_t<_Np>, _Args&&... __args) : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...), _M_index{_Np} { } void _M_reset() noexcept { _M_index = static_cast<__index_type>(variant_npos); } void* _M_storage() const noexcept { return const_cast(static_cast( std::addressof(_M_u))); } 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<_Types...> _M_u; using __index_type = __select_index<_Types...>; __index_type _M_index; }; template using _Variant_storage_alias = _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>; template void __variant_construct_single(_Tp&& __lhs, _Up&& __rhs_mem) { void* __storage = std::addressof(__lhs._M_u); using _Type = remove_reference_t; if constexpr (!is_same_v<_Type, __variant_cookie>) ::new (__storage) _Type(std::forward(__rhs_mem)); } template void __variant_construct(_Tp&& __lhs, _Up&& __rhs) { __lhs._M_index = __rhs._M_index; __variant::__raw_visit([&__lhs](auto&& __rhs_mem) mutable { __variant_construct_single(std::forward<_Tp>(__lhs), std::forward(__rhs_mem)); }, __variant_cast<_Types...>(std::forward<_Up>(__rhs))); } template struct _Copy_ctor_base : _Variant_storage_alias<_Types...> { using _Base = _Variant_storage_alias<_Types...>; using _Base::_Base; _Copy_ctor_base(const _Copy_ctor_base& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor) { __variant_construct<_Types...>(*this, __rhs); } _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 struct _Copy_ctor_base : _Variant_storage_alias<_Types...> { using _Base = _Variant_storage_alias<_Types...>; using _Base::_Base; }; template using _Copy_ctor_alias = _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>; template struct _Move_ctor_base : _Copy_ctor_alias<_Types...> { using _Base = _Copy_ctor_alias<_Types...>; using _Base::_Base; _Move_ctor_base(_Move_ctor_base&& __rhs) noexcept(_Traits<_Types...>::_S_nothrow_move_ctor) { __variant_construct<_Types...>(*this, std::move(__rhs)); } template void _M_destructive_move(unsigned short __rhs_index, _Up&& __rhs) { this->_M_reset(); __variant_construct_single(*this, std::forward<_Up>(__rhs)); this->_M_index = __rhs_index; } template void _M_destructive_copy(unsigned short __rhs_index, const _Up& __rhs) { this->_M_reset(); __variant_construct_single(*this, __rhs); this->_M_index = __rhs_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 struct _Move_ctor_base : _Copy_ctor_alias<_Types...> { using _Base = _Copy_ctor_alias<_Types...>; using _Base::_Base; template void _M_destructive_move(unsigned short __rhs_index, _Up&& __rhs) { this->_M_reset(); __variant_construct_single(*this, std::forward<_Up>(__rhs)); this->_M_index = __rhs_index; } template void _M_destructive_copy(unsigned short __rhs_index, const _Up& __rhs) { this->_M_reset(); __variant_construct_single(*this, __rhs); this->_M_index = __rhs_index; } }; template using _Move_ctor_alias = _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>; template struct _Copy_assign_base : _Move_ctor_alias<_Types...> { using _Base = _Move_ctor_alias<_Types...>; using _Base::_Base; _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 { if constexpr (__rhs_index != variant_npos) { if (this->_M_index == __rhs_index) __variant::__get<__rhs_index>(*this) = __rhs_mem; else { using __rhs_type = __remove_cvref_t; if constexpr (is_nothrow_copy_constructible_v<__rhs_type> || !is_nothrow_move_constructible_v<__rhs_type>) this->_M_destructive_copy(__rhs_index, __rhs_mem); else __variant_cast<_Types...>(*this) = variant<_Types...>(std::in_place_index<__rhs_index>, __rhs_mem); } } else this->_M_reset(); }, __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 struct _Copy_assign_base : _Move_ctor_alias<_Types...> { using _Base = _Move_ctor_alias<_Types...>; using _Base::_Base; }; template using _Copy_assign_alias = _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types...>; template struct _Move_assign_base : _Copy_assign_alias<_Types...> { using _Base = _Copy_assign_alias<_Types...>; using _Base::_Base; _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 { if constexpr (__rhs_index != variant_npos) { if (this->_M_index == __rhs_index) __variant::__get<__rhs_index>(*this) = std::move(__rhs_mem); else __variant_cast<_Types...>(*this) .template emplace<__rhs_index>(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 struct _Move_assign_base : _Copy_assign_alias<_Types...> { using _Base = _Copy_assign_alias<_Types...>; using _Base::_Base; }; template using _Move_assign_alias = _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types...>; template 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 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 struct __tuple_count; template inline constexpr size_t __tuple_count_v = __tuple_count<_Tp, _Tuple>::value; template struct __tuple_count<_Tp, tuple<_Types...>> : integral_constant { }; template struct __tuple_count<_Tp, tuple<_First, _Rest...>> : integral_constant< size_t, __tuple_count_v<_Tp, tuple<_Rest...>> + is_same_v<_Tp, _First>> { }; template inline constexpr bool __exactly_once = __tuple_count_v<_Tp, tuple<_Types...>> == 1; template struct _Arr { _Ti _M_x[1]; }; template, bool>, typename = void> struct _Build_FUN { void _S_fun(); }; template struct _Build_FUN<_Ind, _Tp, _Ti, false, void_t{{std::declval<_Tp>()}})>> { static integral_constant _S_fun(_Ti); }; template struct _Build_FUN<_Ind, _Tp, _Ti, true, enable_if_t, bool>>> { static integral_constant _S_fun(_Ti); }; template>> struct _Build_FUNs; template struct _Build_FUNs<_Tp, variant<_Ti...>, index_sequence<_Ind...>> : _Build_FUN<_Ind, _Tp, _Ti>... { using _Build_FUN<_Ind, _Tp, _Ti>::_S_fun...; }; template using _FUN_type = decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>())); template struct __accepted_index : integral_constant { }; template struct __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>> : _FUN_type<_Tp, _Variant> { }; template void* __get_storage(_Variant&& __v) noexcept { return __v._M_storage(); } template struct _Extra_visit_slot_needed { template struct _Variant_never_valueless; template struct _Variant_never_valueless> : bool_constant<__variant::__never_valueless<_Types...>()> {}; static constexpr bool value = (is_same_v<_Maybe_variant_cookie, __variant_cookie> || is_same_v<_Maybe_variant_cookie, __variant_idx_cookie>) && !_Variant_never_valueless<__remove_cvref_t<_Variant>>::value; }; template struct _Multi_array; template struct _Multi_array<_Tp> { template struct __untag_result : false_type { using element_type = _Tp; }; template struct __untag_result : false_type { using element_type = void(*)(_Args...); }; template struct __untag_result<__variant_cookie(*)(_Args...)> : false_type { using element_type = void(*)(_Args...); }; template struct __untag_result<__variant_idx_cookie(*)(_Args...)> : false_type { using element_type = void(*)(_Args...); }; template 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 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>::value ? 1 : 0; using _Tp = _Ret(*)(_Visitor, _Variants...); template 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]; }; # 913 "/usr/include/c++/10/variant" 3 template struct __gen_vtable_impl; # 923 "/usr/include/c++/10/variant" 3 template struct __gen_vtable_impl< _Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>, std::index_sequence<__indices...>> { using _Next = remove_reference_t::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>()); return __vtable; } template static constexpr void _S_apply_all_alts(_Array_type& __vtable, std::index_sequence<__var_indices...>) { if constexpr (_Extra_visit_slot_needed<_Result_type, _Next>::value) (_S_apply_single_alt( __vtable._M_arr[__var_indices + 1], &(__vtable._M_arr[0])), ...); else (_S_apply_single_alt( __vtable._M_arr[__var_indices]), ...); } template 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 { __element = __gen_vtable_impl< remove_reference_t, std::index_sequence<__indices..., __index>>::_S_apply(); } } }; template struct __gen_vtable_impl< _Multi_array<_Result_type (*)(_Visitor, _Variants...)>, std::index_sequence<__indices...>> { using _Array_type = _Multi_array<_Result_type (*)(_Visitor, _Variants...)>; template 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()...); 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() { return _Array_type{&__visit_invoke}; } }; template struct __gen_vtable { using _Array_type = _Multi_array<_Result_type (*)(_Visitor, _Variants...), variant_size_v>...>; static constexpr _Array_type _S_vtable = __gen_vtable_impl<_Array_type, std::index_sequence<>>::_S_apply(); }; template struct _Base_dedup : public _Tp { }; template struct _Variant_hash_base; template struct _Variant_hash_base, std::index_sequence<__indices...>> : _Base_dedup<__indices, __poison_hash>>... { }; } } template void __variant_construct_by_index(_Variant& __v, _Args&&... __args) { __v._M_index = _Np; auto&& __storage = __detail::__variant::__get<_Np>(__v); ::new ((void*)std::addressof(__storage)) remove_reference_t (std::forward<_Args>(__args)...); } template 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() == __detail::__variant::__index_of_v<_Tp, _Types...>; } template constexpr _Tp& get(variant<_Types...>& __v) { 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"); return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v); } template constexpr _Tp&& get(variant<_Types...>&& __v) { 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"); return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>( std::move(__v)); } template constexpr const _Tp& get(const variant<_Types...>& __v) { 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"); return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>(__v); } template constexpr const _Tp&& get(const variant<_Types...>&& __v) { 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"); return std::get<__detail::__variant::__index_of_v<_Tp, _Types...>>( std::move(__v)); } template constexpr add_pointer_t>> 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 constexpr add_pointer_t>> 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 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"); return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>( __ptr); } template constexpr add_pointer_t 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"); return std::get_if<__detail::__variant::__index_of_v<_Tp, _Types...>>( __ptr); } struct monostate { }; # 1192 "/usr/include/c++/10/variant" 3 template 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 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 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 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 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 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 requires (three_way_comparable<_Types> && ...) constexpr common_comparison_category_t...> operator<=>(const variant<_Types...>& __v, const variant<_Types...>& __w) { common_comparison_category_t...> __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; } # 1240 "/usr/include/c++/10/variant" 3 template constexpr decltype(auto) visit(_Visitor&&, _Variants&&...); template 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 enable_if_t && ...) && (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 class variant : private __detail::__variant::_Variant_base<_Types...>, private _Enable_default_constructor< __detail::__variant::_Traits<_Types...>::_S_default_ctor, variant<_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 friend decltype(auto) __variant_cast(_Tp&&); template friend void __variant_construct_by_index(_Variant& __v, _Args&&... __args); 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...>; using _Default_ctor_enabler = _Enable_default_constructor< __detail::__variant::_Traits<_Types...>::_S_default_ctor, variant<_Types...>>; template static constexpr bool __not_self = !is_same_v<__remove_cvref_t<_Tp>, variant>; template static constexpr bool __exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>; template static constexpr size_t __accepted_index = __detail::__variant::__accepted_index<_Tp, variant>::value; template> using __to_type = variant_alternative_t<_Np, variant>; template>> using __accepted_type = __to_type<__accepted_index<_Tp>>; template static constexpr size_t __index_of = __detail::__variant::__index_of_v<_Tp, _Types...>; using _Traits = __detail::__variant::_Traits<_Types...>; template struct __is_in_place_tag : false_type { }; template struct __is_in_place_tag> : true_type { }; template struct __is_in_place_tag> : true_type { }; template static constexpr bool __not_in_place_tag = !__is_in_place_tag<__remove_cvref_t<_Tp>>::value; public: variant() = default; variant(const variant& __rhs) = default; variant(variant&&) = default; variant& operator=(const variant&) = default; variant& operator=(variant&&) = default; ~variant() = default; template, 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 && 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 && 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, typename = enable_if_t>> constexpr explicit variant(in_place_index_t<_Np>, _Args&&... __args) : _Base(in_place_index<_Np>, std::forward<_Args>(__args)...), _Default_ctor_enabler(_Enable_default_constructor_tag{}) { } template, typename = enable_if_t&, _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)...), _Default_ctor_enabler(_Enable_default_constructor_tag{}) { } template 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 operator=(variant(std::forward<_Tp>(__rhs))); } return *this; } template enable_if_t && __exactly_once<_Tp>, _Tp&> emplace(_Args&&... __args) { constexpr size_t __index = __index_of<_Tp>; return this->emplace<__index>(std::forward<_Args>(__args)...); } template enable_if_t&, _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 enable_if_t, _Args...>, variant_alternative_t<_Np, variant>&> emplace(_Args&&... __args) { static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); using type = variant_alternative_t<_Np, variant>; if constexpr (is_nothrow_constructible_v) { this->_M_reset(); __variant_construct_by_index<_Np>(*this, std::forward<_Args>(__args)...); } else if constexpr (is_scalar_v) { const type __tmp(std::forward<_Args>(__args)...); this->_M_reset(); __variant_construct_by_index<_Np>(*this, __tmp); } else if constexpr (__detail::__variant::_Never_valueless_alt() && _Traits::_S_move_assign) { variant __tmp(in_place_index<_Np>, std::forward<_Args>(__args)...); *this = std::move(__tmp); } else { this->_M_reset(); try { __variant_construct_by_index<_Np>(*this, std::forward<_Args>(__args)...); } catch(...) { this->_M_index = variant_npos; throw; } } return std::get<_Np>(*this); } template enable_if_t, initializer_list<_Up>&, _Args...>, variant_alternative_t<_Np, variant>&> emplace(initializer_list<_Up> __il, _Args&&... __args) { static_assert(_Np < sizeof...(_Types), "The index must be in [0, number of alternatives)"); using type = variant_alternative_t<_Np, variant>; if constexpr (is_nothrow_constructible_v&, _Args...>) { this->_M_reset(); __variant_construct_by_index<_Np>(*this, __il, std::forward<_Args>(__args)...); } else if constexpr (__detail::__variant::_Never_valueless_alt() && _Traits::_S_move_assign) { variant __tmp(in_place_index<_Np>, __il, std::forward<_Args>(__args)...); *this = std::move(__tmp); } else { this->_M_reset(); try { __variant_construct_by_index<_Np>(*this, __il, std::forward<_Args>(__args)...); } catch(...) { this->_M_index = variant_npos; throw; } } return std::get<_Np>(*this); } 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; } void swap(variant& __rhs) noexcept((__is_nothrow_swappable<_Types>::value && ...) && is_nothrow_move_constructible_v) { __detail::__variant::__raw_idx_visit( [this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (this->index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(*this); using std::swap; swap(__this_mem, __rhs_mem); } else { if (!this->valueless_by_exception()) [[__likely__]] { auto __tmp(std::move(__rhs_mem)); __rhs = std::move(*this); this->_M_destructive_move(__rhs_index, std::move(__tmp)); } else { this->_M_destructive_move(__rhs_index, std::move(__rhs_mem)); __rhs._M_reset(); } } } else { if (!this->valueless_by_exception()) [[__likely__]] { __rhs = std::move(*this); this->_M_reset(); } } }, __rhs); } private: template friend constexpr decltype(auto) __detail::__variant::__get(_Vp&& __v) noexcept; template friend void* __detail::__variant::__get_storage(_Vp&& __v) noexcept; template friend constexpr bool operator <(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); template friend constexpr bool operator <=(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); template friend constexpr bool operator ==(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); template friend constexpr bool operator !=(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); template friend constexpr bool operator >=(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); template friend constexpr bool operator >(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs); }; template 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 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 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 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 constexpr decltype(auto) __do_visit(_Visitor&& __visitor, _Variants&&... __variants) { 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)...); } template constexpr decltype(auto) visit(_Visitor&& __visitor, _Variants&&... __variants) { if ((__variants.valueless_by_exception() || ...)) __throw_bad_variant_access("std::visit: variant is valueless"); using _Result_type = std::invoke_result_t<_Visitor, decltype(std::get<0>(std::declval<_Variants>()))...>; using _Tag = __detail::__variant::__deduce_visit_result<_Result_type>; return std::__do_visit<_Tag>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); } template constexpr _Res visit(_Visitor&& __visitor, _Variants&&... __variants) { if ((__variants.valueless_by_exception() || ...)) __throw_bad_variant_access("std::visit: variant is valueless"); return std::__do_visit<_Res>(std::forward<_Visitor>(__visitor), std::forward<_Variants>(__variants)...); } template struct __variant_hash_call_base_impl { size_t operator()(const variant<_Types...>& __t) const noexcept((is_nothrow_invocable_v>, _Types> && ...)) { size_t __ret; __detail::__variant::__raw_visit( [&__t, &__ret](auto&& __t_mem) mutable { using _Type = __remove_cvref_t; if constexpr (!is_same_v<_Type, __detail::__variant::__variant_cookie>) __ret = std::hash{}(__t.index()) + std::hash<_Type>{}(__t_mem); else __ret = std::hash{}(__t.index()); }, __t); return __ret; } }; template struct __variant_hash_call_base_impl {}; template using __variant_hash_call_base = __variant_hash_call_base_impl<(__poison_hash>:: __enable_hash_call &&...), _Types...>; template struct hash> : 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 { 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 struct __is_fast_hash>> : bool_constant<(__is_fast_hash<_Types>::value && ...)> { }; } # 31 "all-std.cxx" 2 # 1 "/usr/include/c++/10/version" 1 3 # 33 "/usr/include/c++/10/version" 3 # 34 "/usr/include/c++/10/version" 3 # 32 "all-std.cxx" 2 # 1 "/usr/include/c++/10/memory" 1 3 # 47 "/usr/include/c++/10/memory" 3 # 48 "/usr/include/c++/10/memory" 3 # 68 "/usr/include/c++/10/memory" 3 # 1 "/usr/include/c++/10/bits/stl_raw_storage_iter.h" 1 3 # 59 "/usr/include/c++/10/bits/stl_raw_storage_iter.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class raw_storage_iterator : public iterator { protected: _OutputIterator _M_iter; public: explicit raw_storage_iterator(_OutputIterator __x) : _M_iter(__x) {} raw_storage_iterator& operator*() { return *this; } raw_storage_iterator& operator=(const _Tp& __element) { std::_Construct(std::__addressof(*_M_iter), __element); return *this; } raw_storage_iterator& operator=(_Tp&& __element) { std::_Construct(std::__addressof(*_M_iter), std::move(__element)); return *this; } raw_storage_iterator& operator++() { ++_M_iter; return *this; } raw_storage_iterator operator++(int) { raw_storage_iterator __tmp = *this; ++_M_iter; return __tmp; } _OutputIterator base() const { return _M_iter; } }; } # 69 "/usr/include/c++/10/memory" 2 3 # 1 "/usr/include/c++/10/bits/ranges_uninitialized.h" 1 3 # 36 "/usr/include/c++/10/bits/ranges_uninitialized.h" 3 # 1 "/usr/include/c++/10/bits/ranges_algobase.h" 1 3 # 36 "/usr/include/c++/10/bits/ranges_algobase.h" 3 # 1 "/usr/include/c++/10/iterator" 1 3 # 58 "/usr/include/c++/10/iterator" 3 # 59 "/usr/include/c++/10/iterator" 3 # 1 "/usr/include/c++/10/bits/stream_iterator.h" 1 3 # 33 "/usr/include/c++/10/bits/stream_iterator.h" 3 # 34 "/usr/include/c++/10/bits/stream_iterator.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template, typename _Dist = ptrdiff_t> class istream_iterator : public iterator { public: typedef _CharT char_type; typedef _Traits traits_type; typedef basic_istream<_CharT, _Traits> istream_type; private: istream_type* _M_stream; _Tp _M_value; bool _M_ok; public: constexpr istream_iterator() : _M_stream(0), _M_value(), _M_ok(false) {} istream_iterator(istream_type& __s) : _M_stream(std::__addressof(__s)), _M_ok(true) { _M_read(); } istream_iterator(const istream_iterator& __obj) : _M_stream(__obj._M_stream), _M_value(__obj._M_value), _M_ok(__obj._M_ok) { } constexpr istream_iterator(default_sentinel_t) noexcept(is_nothrow_default_constructible_v<_Tp>) : istream_iterator() { } istream_iterator& operator=(const istream_iterator&) = default; ~istream_iterator() = default; const _Tp& operator*() const { ; return _M_value; } const _Tp* operator->() const { return std::__addressof((operator*())); } istream_iterator& operator++() { ; _M_read(); return *this; } istream_iterator operator++(int) { ; istream_iterator __tmp = *this; _M_read(); return __tmp; } private: bool _M_equal(const istream_iterator& __x) const { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } void _M_read() { if (_M_stream && !(*_M_stream >> _M_value)) { _M_stream = 0; _M_ok = false; } } friend bool operator==(const istream_iterator& __x, const istream_iterator& __y) { return __x._M_equal(__y); } friend bool operator!=(const istream_iterator& __x, const istream_iterator& __y) { return !__x._M_equal(__y); } friend bool operator==(const istream_iterator& __i, default_sentinel_t) { return !__i._M_stream; } }; # 174 "/usr/include/c++/10/bits/stream_iterator.h" 3 template > class ostream_iterator : public iterator { public: using difference_type = ptrdiff_t; typedef _CharT char_type; typedef _Traits traits_type; typedef basic_ostream<_CharT, _Traits> ostream_type; private: ostream_type* _M_stream; const _CharT* _M_string; public: constexpr ostream_iterator() noexcept : _M_stream(nullptr), _M_string(nullptr) { } ostream_iterator(ostream_type& __s) : _M_stream(std::__addressof(__s)), _M_string(0) {} # 214 "/usr/include/c++/10/bits/stream_iterator.h" 3 ostream_iterator(ostream_type& __s, const _CharT* __c) : _M_stream(std::__addressof(__s)), _M_string(__c) { } ostream_iterator(const ostream_iterator& __obj) : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } ostream_iterator& operator=(const ostream_iterator&) = default; ostream_iterator& operator=(const _Tp& __value) { ; *_M_stream << __value; if (_M_string) *_M_stream << _M_string; return *this; } ostream_iterator& operator*() { return *this; } ostream_iterator& operator++() { return *this; } ostream_iterator& operator++(int) { return *this; } }; } # 66 "/usr/include/c++/10/iterator" 2 3 # 1 "/usr/include/c++/10/bits/streambuf_iterator.h" 1 3 # 33 "/usr/include/c++/10/bits/streambuf_iterator.h" 3 # 34 "/usr/include/c++/10/bits/streambuf_iterator.h" 3 # 1 "/usr/include/c++/10/streambuf" 1 3 # 36 "/usr/include/c++/10/streambuf" 3 # 37 "/usr/include/c++/10/streambuf" 3 # 1 "/usr/include/c++/10/bits/ios_base.h" 1 3 # 37 "/usr/include/c++/10/bits/ios_base.h" 3 # 38 "/usr/include/c++/10/bits/ios_base.h" 3 # 1 "/usr/include/c++/10/bits/locale_classes.h" 1 3 # 37 "/usr/include/c++/10/bits/locale_classes.h" 3 # 38 "/usr/include/c++/10/bits/locale_classes.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 62 "/usr/include/c++/10/bits/locale_classes.h" 3 class locale { public: typedef int category; class facet; class id; class _Impl; friend class facet; friend class _Impl; template friend bool has_facet(const locale&) throw(); template friend const _Facet& use_facet(const locale&); template friend struct __use_cache; # 98 "/usr/include/c++/10/bits/locale_classes.h" 3 static const category none = 0; static const category ctype = 1L << 0; static const category numeric = 1L << 1; static const category collate = 1L << 2; static const category time = 1L << 3; static const category monetary = 1L << 4; static const category messages = 1L << 5; static const category all = (ctype | numeric | collate | time | monetary | messages); # 117 "/usr/include/c++/10/bits/locale_classes.h" 3 locale() throw(); # 126 "/usr/include/c++/10/bits/locale_classes.h" 3 locale(const locale& __other) throw(); # 136 "/usr/include/c++/10/bits/locale_classes.h" 3 explicit locale(const char* __s); # 151 "/usr/include/c++/10/bits/locale_classes.h" 3 locale(const locale& __base, const char* __s, category __cat); # 162 "/usr/include/c++/10/bits/locale_classes.h" 3 explicit locale(const std::string& __s) : locale(__s.c_str()) { } # 177 "/usr/include/c++/10/bits/locale_classes.h" 3 locale(const locale& __base, const std::string& __s, category __cat) : locale(__base, __s.c_str(), __cat) { } # 192 "/usr/include/c++/10/bits/locale_classes.h" 3 locale(const locale& __base, const locale& __add, category __cat); # 205 "/usr/include/c++/10/bits/locale_classes.h" 3 template locale(const locale& __other, _Facet* __f); ~locale() throw(); # 219 "/usr/include/c++/10/bits/locale_classes.h" 3 const locale& operator=(const locale& __other) throw(); # 234 "/usr/include/c++/10/bits/locale_classes.h" 3 template locale combine(const locale& __other) const; __attribute ((__abi_tag__ ("cxx11"))) string name() const; # 254 "/usr/include/c++/10/bits/locale_classes.h" 3 bool operator==(const locale& __other) const throw(); # 284 "/usr/include/c++/10/bits/locale_classes.h" 3 template bool operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, const basic_string<_Char, _Traits, _Alloc>& __s2) const; # 300 "/usr/include/c++/10/bits/locale_classes.h" 3 static locale global(const locale& __loc); static const locale& classic(); private: _Impl* _M_impl; static _Impl* _S_classic; static _Impl* _S_global; static const char* const* const _S_categories; # 335 "/usr/include/c++/10/bits/locale_classes.h" 3 enum { _S_categories_size = 6 + 6 }; static __gthread_once_t _S_once; explicit locale(_Impl*) throw(); static void _S_initialize(); static void _S_initialize_once() throw(); static category _S_normalize_category(category); void _M_coalesce(const locale& __base, const locale& __add, category __cat); static const id* const _S_twinned_facets[]; }; # 373 "/usr/include/c++/10/bits/locale_classes.h" 3 class locale::facet { private: friend class locale; friend class locale::_Impl; mutable _Atomic_word _M_refcount; static __c_locale _S_c_locale; static const char _S_c_name[2]; static __gthread_once_t _S_once; static void _S_initialize_once(); protected: # 404 "/usr/include/c++/10/bits/locale_classes.h" 3 explicit facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) { } virtual ~facet(); static void _S_create_c_locale(__c_locale& __cloc, const char* __s, __c_locale __old = 0); static __c_locale _S_clone_c_locale(__c_locale& __cloc) throw(); static void _S_destroy_c_locale(__c_locale& __cloc); static __c_locale _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s); static __c_locale _S_get_c_locale(); __attribute__ ((__const__)) static const char* _S_get_c_name() throw(); # 440 "/usr/include/c++/10/bits/locale_classes.h" 3 facet(const facet&) = delete; facet& operator=(const facet&) = delete; private: void _M_add_reference() const throw() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } void _M_remove_reference() const throw() { ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) { ; try { delete this; } catch(...) { } } } const facet* _M_sso_shim(const id*) const; const facet* _M_cow_shim(const id*) const; protected: class __shim; }; # 485 "/usr/include/c++/10/bits/locale_classes.h" 3 class locale::id { private: friend class locale; friend class locale::_Impl; template friend const _Facet& use_facet(const locale&); template friend bool has_facet(const locale&) throw(); mutable size_t _M_index; static _Atomic_word _S_refcount; void operator=(const id&); id(const id&); public: id() { } size_t _M_id() const throw(); }; class locale::_Impl { public: friend class locale; friend class locale::facet; template friend bool has_facet(const locale&) throw(); template friend const _Facet& use_facet(const locale&); template 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 void _M_init_facet(_Facet* __facet) { _M_install_facet(&_Facet::id, __facet); } template void _M_init_facet_unchecked(_Facet* __facet) { __facet->_M_add_reference(); _M_facets[_Facet::id._M_id()] = __facet; } void _M_install_cache(const facet*, size_t); void _M_init_extra(facet**); void _M_init_extra(void*, void*, const char*, const char*); }; # 643 "/usr/include/c++/10/bits/locale_classes.h" 3 template class __cxx11:: collate : public locale::facet { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; protected: __c_locale _M_c_locale_collate; public: static locale::id id; # 670 "/usr/include/c++/10/bits/locale_classes.h" 3 explicit collate(size_t __refs = 0) : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) { } # 684 "/usr/include/c++/10/bits/locale_classes.h" 3 explicit collate(__c_locale __cloc, size_t __refs = 0) : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) { } # 701 "/usr/include/c++/10/bits/locale_classes.h" 3 int compare(const _CharT* __lo1, const _CharT* __hi1, const _CharT* __lo2, const _CharT* __hi2) const { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } # 720 "/usr/include/c++/10/bits/locale_classes.h" 3 string_type transform(const _CharT* __lo, const _CharT* __hi) const { return this->do_transform(__lo, __hi); } # 734 "/usr/include/c++/10/bits/locale_classes.h" 3 long hash(const _CharT* __lo, const _CharT* __hi) const { return this->do_hash(__lo, __hi); } int _M_compare(const _CharT*, const _CharT*) const throw(); size_t _M_transform(_CharT*, const _CharT*, size_t) const throw(); protected: virtual ~collate() { _S_destroy_c_locale(_M_c_locale_collate); } # 763 "/usr/include/c++/10/bits/locale_classes.h" 3 virtual int do_compare(const _CharT* __lo1, const _CharT* __hi1, const _CharT* __lo2, const _CharT* __hi2) const; # 777 "/usr/include/c++/10/bits/locale_classes.h" 3 virtual string_type do_transform(const _CharT* __lo, const _CharT* __hi) const; # 790 "/usr/include/c++/10/bits/locale_classes.h" 3 virtual long do_hash(const _CharT* __lo, const _CharT* __hi) const; }; template locale::id collate<_CharT>::id; template<> int collate::_M_compare(const char*, const char*) const throw(); template<> size_t collate::_M_transform(char*, const char*, size_t) const throw(); template<> int collate::_M_compare(const wchar_t*, const wchar_t*) const throw(); template<> size_t collate::_M_transform(wchar_t*, const wchar_t*, size_t) const throw(); template class __cxx11:: collate_byname : public collate<_CharT> { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; explicit collate_byname(const char* __s, size_t __refs = 0) : collate<_CharT>(__refs) { if (__builtin_strcmp(__s, "C") != 0 && __builtin_strcmp(__s, "POSIX") != 0) { this->_S_destroy_c_locale(this->_M_c_locale_collate); this->_S_create_c_locale(this->_M_c_locale_collate, __s); } } explicit collate_byname(const string& __s, size_t __refs = 0) : collate_byname(__s.c_str(), __refs) { } protected: virtual ~collate_byname() { } }; } # 1 "/usr/include/c++/10/bits/locale_classes.tcc" 1 3 # 37 "/usr/include/c++/10/bits/locale_classes.tcc" 3 # 38 "/usr/include/c++/10/bits/locale_classes.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template 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 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 bool locale:: operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, const basic_string<_CharT, _Traits, _Alloc>& __s2) const { typedef std::collate<_CharT> __collate_type; const __collate_type& __collate = use_facet<__collate_type>(*this); return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), __s2.data(), __s2.data() + __s2.length()) < 0); } # 102 "/usr/include/c++/10/bits/locale_classes.tcc" 3 template bool has_facet(const locale& __loc) throw() { const size_t __i = _Facet::id._M_id(); const locale::facet** __facets = __loc._M_impl->_M_facets; return (__i < __loc._M_impl->_M_facets_size && dynamic_cast(__facets[__i])); } # 130 "/usr/include/c++/10/bits/locale_classes.tcc" 3 template const _Facet& use_facet(const locale& __loc) { const size_t __i = _Facet::id._M_id(); const locale::facet** __facets = __loc._M_impl->_M_facets; if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i]) __throw_bad_cast(); return dynamic_cast(*__facets[__i]); } template int collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw () { return 0; } template size_t collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw () { return 0; } template 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 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 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:: __digits - 7))); return static_cast(__val); } extern template class collate; extern template class collate_byname; extern template const collate& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template class collate; extern template class collate_byname; extern template const collate& use_facet >(const locale&); extern template bool has_facet >(const locale&); } # 854 "/usr/include/c++/10/bits/locale_classes.h" 2 3 # 42 "/usr/include/c++/10/bits/ios_base.h" 2 3 # 1 "/usr/include/c++/10/system_error" 1 3 # 32 "/usr/include/c++/10/system_error" 3 # 33 "/usr/include/c++/10/system_error" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/error_constants.h" 1 3 # 34 "/usr/include/x86_64-linux-gnu/c++/10/bits/error_constants.h" 3 # 1 "/usr/include/c++/10/cerrno" 1 3 # 39 "/usr/include/c++/10/cerrno" 3 # 40 "/usr/include/c++/10/cerrno" 3 # 35 "/usr/include/x86_64-linux-gnu/c++/10/bits/error_constants.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { enum class errc { address_family_not_supported = 97, address_in_use = 98, address_not_available = 99, already_connected = 106, argument_list_too_long = 7, argument_out_of_domain = 33, bad_address = 14, bad_file_descriptor = 9, bad_message = 74, broken_pipe = 32, connection_aborted = 103, connection_already_in_progress = 114, connection_refused = 111, connection_reset = 104, cross_device_link = 18, destination_address_required = 89, device_or_resource_busy = 16, directory_not_empty = 39, executable_format_error = 8, file_exists = 17, file_too_large = 27, filename_too_long = 36, function_not_supported = 38, host_unreachable = 113, identifier_removed = 43, illegal_byte_sequence = 84, inappropriate_io_control_operation = 25, interrupted = 4, invalid_argument = 22, invalid_seek = 29, io_error = 5, is_a_directory = 21, message_size = 90, network_down = 100, network_reset = 102, network_unreachable = 101, no_buffer_space = 105, no_child_process = 10, no_link = 67, no_lock_available = 37, no_message_available = 61, no_message = 42, no_protocol_option = 92, no_space_on_device = 28, no_stream_resources = 63, no_such_device_or_address = 6, no_such_device = 19, no_such_file_or_directory = 2, no_such_process = 3, not_a_directory = 20, not_a_socket = 88, not_a_stream = 60, not_connected = 107, not_enough_memory = 12, not_supported = 95, operation_canceled = 125, operation_in_progress = 115, operation_not_permitted = 1, operation_not_supported = 95, operation_would_block = 11, owner_dead = 130, permission_denied = 13, protocol_error = 71, protocol_not_supported = 93, read_only_file_system = 30, resource_deadlock_would_occur = 35, resource_unavailable_try_again = 11, result_out_of_range = 34, state_not_recoverable = 131, stream_timeout = 62, text_file_busy = 26, timed_out = 110, too_many_files_open_in_system = 23, too_many_files_open = 24, too_many_links = 31, too_many_symbolic_link_levels = 40, value_too_large = 75, wrong_protocol_type = 91 }; } # 40 "/usr/include/c++/10/system_error" 2 3 # 1 "/usr/include/c++/10/stdexcept" 1 3 # 36 "/usr/include/c++/10/stdexcept" 3 # 37 "/usr/include/c++/10/stdexcept" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct __cow_string { union { const char* _M_p; char _M_bytes[sizeof(const char*)]; }; __cow_string(); __cow_string(const std::string&); __cow_string(const char*, size_t); __cow_string(const __cow_string&) noexcept; __cow_string& operator=(const __cow_string&) noexcept; ~__cow_string(); __cow_string(__cow_string&&) noexcept; __cow_string& operator=(__cow_string&&) noexcept; }; typedef basic_string __sso_string; # 113 "/usr/include/c++/10/stdexcept" 3 class logic_error : public exception { __cow_string _M_msg; public: explicit logic_error(const string& __arg) ; explicit logic_error(const char*) ; logic_error(logic_error&&) noexcept; logic_error& operator=(logic_error&&) noexcept; logic_error(const logic_error&) noexcept; logic_error& operator=(const logic_error&) noexcept; virtual ~logic_error() noexcept; virtual const char* what() const noexcept; }; class domain_error : public logic_error { public: explicit domain_error(const string& __arg) ; explicit domain_error(const char*) ; domain_error(const domain_error&) = default; domain_error& operator=(const domain_error&) = default; domain_error(domain_error&&) = default; domain_error& operator=(domain_error&&) = default; virtual ~domain_error() noexcept; }; class invalid_argument : public logic_error { public: explicit invalid_argument(const string& __arg) ; explicit invalid_argument(const char*) ; invalid_argument(const invalid_argument&) = default; invalid_argument& operator=(const invalid_argument&) = default; invalid_argument(invalid_argument&&) = default; invalid_argument& operator=(invalid_argument&&) = default; virtual ~invalid_argument() noexcept; }; class length_error : public logic_error { public: explicit length_error(const string& __arg) ; explicit length_error(const char*) ; length_error(const length_error&) = default; length_error& operator=(const length_error&) = default; length_error(length_error&&) = default; length_error& operator=(length_error&&) = default; virtual ~length_error() noexcept; }; class out_of_range : public logic_error { public: explicit out_of_range(const string& __arg) ; explicit out_of_range(const char*) ; out_of_range(const out_of_range&) = default; out_of_range& operator=(const out_of_range&) = default; out_of_range(out_of_range&&) = default; out_of_range& operator=(out_of_range&&) = default; virtual ~out_of_range() noexcept; }; class runtime_error : public exception { __cow_string _M_msg; public: explicit runtime_error(const string& __arg) ; explicit runtime_error(const char*) ; runtime_error(runtime_error&&) noexcept; runtime_error& operator=(runtime_error&&) noexcept; runtime_error(const runtime_error&) noexcept; runtime_error& operator=(const runtime_error&) noexcept; virtual ~runtime_error() noexcept; virtual const char* what() const noexcept; }; class range_error : public runtime_error { public: explicit range_error(const string& __arg) ; explicit range_error(const char*) ; range_error(const range_error&) = default; range_error& operator=(const range_error&) = default; range_error(range_error&&) = default; range_error& operator=(range_error&&) = default; virtual ~range_error() noexcept; }; class overflow_error : public runtime_error { public: explicit overflow_error(const string& __arg) ; explicit overflow_error(const char*) ; overflow_error(const overflow_error&) = default; overflow_error& operator=(const overflow_error&) = default; overflow_error(overflow_error&&) = default; overflow_error& operator=(overflow_error&&) = default; virtual ~overflow_error() noexcept; }; class underflow_error : public runtime_error { public: explicit underflow_error(const string& __arg) ; explicit underflow_error(const char*) ; underflow_error(const underflow_error&) = default; underflow_error& operator=(const underflow_error&) = default; underflow_error(underflow_error&&) = default; underflow_error& operator=(underflow_error&&) = default; virtual ~underflow_error() noexcept; }; } # 42 "/usr/include/c++/10/system_error" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { class error_code; class error_condition; class system_error; template struct is_error_code_enum : public false_type { }; template struct is_error_condition_enum : public false_type { }; template<> struct is_error_condition_enum : public true_type { }; template inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value; template inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; inline namespace _V2 { # 89 "/usr/include/c++/10/system_error" 3 class error_category { public: constexpr error_category() noexcept = default; virtual ~error_category(); error_category(const error_category&) = delete; error_category& operator=(const error_category&) = delete; virtual const char* name() const noexcept = 0; private: __attribute ((__abi_tag__ ("cxx11"))) virtual __cow_string _M_message(int) const; public: __attribute ((__abi_tag__ ("cxx11"))) virtual string message(int) const = 0; # 125 "/usr/include/c++/10/system_error" 3 public: virtual error_condition default_error_condition(int __i) const noexcept; virtual bool equivalent(int __i, const error_condition& __cond) const noexcept; virtual bool equivalent(const error_code& __code, int __i) const noexcept; bool operator==(const error_category& __other) const noexcept { return this == &__other; } strong_ordering operator<=>(const error_category& __rhs) const noexcept { return std::compare_three_way()(this, &__rhs); } # 152 "/usr/include/c++/10/system_error" 3 }; __attribute__ ((__const__)) const error_category& generic_category() noexcept; __attribute__ ((__const__)) const error_category& system_category() noexcept; } error_code make_error_code(errc) noexcept; # 180 "/usr/include/c++/10/system_error" 3 struct error_code { error_code() noexcept : _M_value(0), _M_cat(&system_category()) { } error_code(int __v, const error_category& __cat) noexcept : _M_value(__v), _M_cat(&__cat) { } template::value>::type> error_code(_ErrorCodeEnum __e) noexcept { *this = make_error_code(__e); } void assign(int __v, const error_category& __cat) noexcept { _M_value = __v; _M_cat = &__cat; } void clear() noexcept { assign(0, system_category()); } template typename enable_if::value, error_code&>::type operator=(_ErrorCodeEnum __e) noexcept { return *this = make_error_code(__e); } int value() const noexcept { return _M_value; } const error_category& category() const noexcept { return *_M_cat; } error_condition default_error_condition() const noexcept; __attribute ((__abi_tag__ ("cxx11"))) string message() const { return category().message(value()); } explicit operator bool() const noexcept { return _M_value != 0; } private: int _M_value; const error_category* _M_cat; }; inline error_code make_error_code(errc __e) noexcept { return error_code(static_cast(__e), generic_category()); } 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(); } # 260 "/usr/include/c++/10/system_error" 3 template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) { return (__os << __e.category().name() << ':' << __e.value()); } error_condition make_error_condition(errc) noexcept; # 278 "/usr/include/c++/10/system_error" 3 struct error_condition { error_condition() noexcept : _M_value(0), _M_cat(&generic_category()) { } error_condition(int __v, const error_category& __cat) noexcept : _M_value(__v), _M_cat(&__cat) { } template::value>::type> error_condition(_ErrorConditionEnum __e) noexcept { *this = make_error_condition(__e); } void assign(int __v, const error_category& __cat) noexcept { _M_value = __v; _M_cat = &__cat; } template typename enable_if::value, error_condition&>::type operator=(_ErrorConditionEnum __e) noexcept { return *this = make_error_condition(__e); } void clear() noexcept { assign(0, generic_category()); } int value() const noexcept { return _M_value; } const error_category& category() const noexcept { return *_M_cat; } __attribute ((__abi_tag__ ("cxx11"))) string message() const { return category().message(value()); } explicit operator bool() const noexcept { return _M_value != 0; } private: int _M_value; const error_category* _M_cat; }; inline error_condition make_error_condition(errc __e) noexcept { return error_condition(static_cast(__e), generic_category()); } inline bool operator==(const error_code& __lhs, const error_code& __rhs) noexcept { return (__lhs.category() == __rhs.category() && __lhs.value() == __rhs.value()); } inline bool operator==(const error_code& __lhs, const error_condition& __rhs) noexcept { return (__lhs.category().equivalent(__lhs.value(), __rhs) || __rhs.category().equivalent(__lhs, __rhs.value())); } inline bool operator==(const error_condition& __lhs, const error_condition& __rhs) noexcept { return (__lhs.category() == __rhs.category() && __lhs.value() == __rhs.value()); } 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(); } # 428 "/usr/include/c++/10/system_error" 3 class system_error : public std::runtime_error { private: error_code _M_code; public: system_error(error_code __ec = error_code()) : runtime_error(__ec.message()), _M_code(__ec) { } system_error(error_code __ec, const string& __what) : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { } system_error(error_code __ec, const char* __what) : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } system_error(int __v, const error_category& __ecat, const char* __what) : system_error(error_code(__v, __ecat), __what) { } system_error(int __v, const error_category& __ecat) : runtime_error(error_code(__v, __ecat).message()), _M_code(__v, __ecat) { } system_error(int __v, const error_category& __ecat, const string& __what) : runtime_error(__what + ": " + error_code(__v, __ecat).message()), _M_code(__v, __ecat) { } system_error (const system_error &) = default; system_error &operator= (const system_error &) = default; virtual ~system_error() noexcept; const error_code& code() const noexcept { return _M_code; } }; } namespace std __attribute__ ((__visibility__ ("default"))) { template<> struct hash : public __hash_base { 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 : public __hash_base { size_t operator()(const error_condition& __e) const noexcept { const size_t __tmp = std::_Hash_impl::hash(__e.value()); return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); } }; } # 47 "/usr/include/c++/10/bits/ios_base.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { enum _Ios_Fmtflags { _S_boolalpha = 1L << 0, _S_dec = 1L << 1, _S_fixed = 1L << 2, _S_hex = 1L << 3, _S_internal = 1L << 4, _S_left = 1L << 5, _S_oct = 1L << 6, _S_right = 1L << 7, _S_scientific = 1L << 8, _S_showbase = 1L << 9, _S_showpoint = 1L << 10, _S_showpos = 1L << 11, _S_skipws = 1L << 12, _S_unitbuf = 1L << 13, _S_uppercase = 1L << 14, _S_adjustfield = _S_left | _S_right | _S_internal, _S_basefield = _S_dec | _S_oct | _S_hex, _S_floatfield = _S_scientific | _S_fixed, _S_ios_fmtflags_end = 1L << 16, _S_ios_fmtflags_max = 0x7fffffff, _S_ios_fmtflags_min = ~0x7fffffff }; inline constexpr _Ios_Fmtflags operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } inline constexpr _Ios_Fmtflags operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } inline constexpr _Ios_Fmtflags operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } inline constexpr _Ios_Fmtflags operator~(_Ios_Fmtflags __a) { return _Ios_Fmtflags(~static_cast(__a)); } inline const _Ios_Fmtflags& operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a | __b; } inline const _Ios_Fmtflags& operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a & __b; } inline const _Ios_Fmtflags& operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a ^ __b; } enum _Ios_Openmode { _S_app = 1L << 0, _S_ate = 1L << 1, _S_bin = 1L << 2, _S_in = 1L << 3, _S_out = 1L << 4, _S_trunc = 1L << 5, _S_ios_openmode_end = 1L << 16, _S_ios_openmode_max = 0x7fffffff, _S_ios_openmode_min = ~0x7fffffff }; inline constexpr _Ios_Openmode operator&(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } inline constexpr _Ios_Openmode operator|(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } inline constexpr _Ios_Openmode operator^(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } inline constexpr _Ios_Openmode operator~(_Ios_Openmode __a) { return _Ios_Openmode(~static_cast(__a)); } inline const _Ios_Openmode& operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a | __b; } inline const _Ios_Openmode& operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a & __b; } inline const _Ios_Openmode& operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a ^ __b; } enum _Ios_Iostate { _S_goodbit = 0, _S_badbit = 1L << 0, _S_eofbit = 1L << 1, _S_failbit = 1L << 2, _S_ios_iostate_end = 1L << 16, _S_ios_iostate_max = 0x7fffffff, _S_ios_iostate_min = ~0x7fffffff }; inline constexpr _Ios_Iostate operator&(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } inline constexpr _Ios_Iostate operator|(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } inline constexpr _Ios_Iostate operator^(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } inline constexpr _Ios_Iostate operator~(_Ios_Iostate __a) { return _Ios_Iostate(~static_cast(__a)); } inline const _Ios_Iostate& operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a | __b; } inline const _Ios_Iostate& operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a & __b; } inline const _Ios_Iostate& operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a ^ __b; } enum _Ios_Seekdir { _S_beg = 0, _S_cur = 1, _S_end = 2, _S_ios_seekdir_end = 1L << 16 }; enum class io_errc { stream = 1 }; template <> struct is_error_code_enum : public true_type { }; const error_category& iostream_category() noexcept; inline error_code make_error_code(io_errc __e) noexcept { return error_code(static_cast(__e), iostream_category()); } inline error_condition make_error_condition(io_errc __e) noexcept { return error_condition(static_cast(__e), iostream_category()); } # 228 "/usr/include/c++/10/bits/ios_base.h" 3 class ios_base { # 246 "/usr/include/c++/10/bits/ios_base.h" 3 public: # 255 "/usr/include/c++/10/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(); }; # 341 "/usr/include/c++/10/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; # 416 "/usr/include/c++/10/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; # 447 "/usr/include/c++/10/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; # 479 "/usr/include/c++/10/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; # 512 "/usr/include/c++/10/bits/ios_base.h" 3 enum event { erase_event, imbue_event, copyfmt_event }; # 529 "/usr/include/c++/10/bits/ios_base.h" 3 typedef void (*event_callback) (event __e, ios_base& __b, int __i); # 541 "/usr/include/c++/10/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; } # 659 "/usr/include/c++/10/bits/ios_base.h" 3 fmtflags flags(fmtflags __fmtfl) { fmtflags __old = _M_flags; _M_flags = __fmtfl; return __old; } # 675 "/usr/include/c++/10/bits/ios_base.h" 3 fmtflags setf(fmtflags __fmtfl) { fmtflags __old = _M_flags; _M_flags |= __fmtfl; return __old; } # 692 "/usr/include/c++/10/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; } # 718 "/usr/include/c++/10/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; } # 769 "/usr/include/c++/10/bits/ios_base.h" 3 static bool sync_with_stdio(bool __sync = true); # 781 "/usr/include/c++/10/bits/ios_base.h" 3 locale imbue(const locale& __loc) throw(); # 792 "/usr/include/c++/10/bits/ios_base.h" 3 locale getloc() const { return _M_ios_locale; } # 803 "/usr/include/c++/10/bits/ios_base.h" 3 const locale& _M_getloc() const { return _M_ios_locale; } # 822 "/usr/include/c++/10/bits/ios_base.h" 3 static int xalloc() throw(); # 838 "/usr/include/c++/10/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; } # 859 "/usr/include/c++/10/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; } # 876 "/usr/include/c++/10/bits/ios_base.h" 3 virtual ~ios_base(); protected: ios_base() throw (); # 890 "/usr/include/c++/10/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; } } # 42 "/usr/include/c++/10/streambuf" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template streamsize __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, basic_streambuf<_CharT, _Traits>*, bool&); # 121 "/usr/include/c++/10/streambuf" 3 template 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 __streambuf_type; friend class basic_ios; friend class basic_istream; friend class basic_ostream; friend class istreambuf_iterator; friend class ostreambuf_iterator; friend streamsize __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, _CharT2*>::__type __copy_move_a2(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, _CharT2*); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, istreambuf_iterator<_CharT2> >::__type find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, const _CharT2&); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, void>::__type advance(istreambuf_iterator<_CharT2>&, _Distance); template friend basic_istream<_CharT2, _Traits2>& operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); template friend basic_istream<_CharT2, _Traits2>& operator>>(basic_istream<_CharT2, _Traits2>&, basic_string<_CharT2, _Traits2, _Alloc>&); template friend basic_istream<_CharT2, _Traits2>& getline(basic_istream<_CharT2, _Traits2>&, basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); protected: char_type* _M_in_beg; char_type* _M_in_cur; char_type* _M_in_end; char_type* _M_out_beg; char_type* _M_out_cur; char_type* _M_out_end; locale _M_buf_locale; public: virtual ~basic_streambuf() { } # 215 "/usr/include/c++/10/streambuf" 3 locale pubimbue(const locale& __loc) { locale __tmp(this->getloc()); this->imbue(__loc); _M_buf_locale = __loc; return __tmp; } # 232 "/usr/include/c++/10/streambuf" 3 locale getloc() const { return _M_buf_locale; } # 245 "/usr/include/c++/10/streambuf" 3 basic_streambuf* pubsetbuf(char_type* __s, streamsize __n) { return this->setbuf(__s, __n); } # 257 "/usr/include/c++/10/streambuf" 3 pos_type pubseekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out) { return this->seekoff(__off, __way, __mode); } # 269 "/usr/include/c++/10/streambuf" 3 pos_type pubseekpos(pos_type __sp, ios_base::openmode __mode = ios_base::in | ios_base::out) { return this->seekpos(__sp, __mode); } int pubsync() { return this->sync(); } # 290 "/usr/include/c++/10/streambuf" 3 streamsize in_avail() { const streamsize __ret = this->egptr() - this->gptr(); return __ret ? __ret : this->showmanyc(); } # 304 "/usr/include/c++/10/streambuf" 3 int_type snextc() { int_type __ret = traits_type::eof(); if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), __ret), true)) __ret = this->sgetc(); return __ret; } # 322 "/usr/include/c++/10/streambuf" 3 int_type sbumpc() { int_type __ret; if (__builtin_expect(this->gptr() < this->egptr(), true)) { __ret = traits_type::to_int_type(*this->gptr()); this->gbump(1); } else __ret = this->uflow(); return __ret; } # 344 "/usr/include/c++/10/streambuf" 3 int_type sgetc() { int_type __ret; if (__builtin_expect(this->gptr() < this->egptr(), true)) __ret = traits_type::to_int_type(*this->gptr()); else __ret = this->underflow(); return __ret; } # 363 "/usr/include/c++/10/streambuf" 3 streamsize sgetn(char_type* __s, streamsize __n) { return this->xsgetn(__s, __n); } # 378 "/usr/include/c++/10/streambuf" 3 int_type sputbackc(char_type __c) { int_type __ret; const bool __testpos = this->eback() < this->gptr(); if (__builtin_expect(!__testpos || !traits_type::eq(__c, this->gptr()[-1]), false)) __ret = this->pbackfail(traits_type::to_int_type(__c)); else { this->gbump(-1); __ret = traits_type::to_int_type(*this->gptr()); } return __ret; } # 403 "/usr/include/c++/10/streambuf" 3 int_type sungetc() { int_type __ret; if (__builtin_expect(this->eback() < this->gptr(), true)) { this->gbump(-1); __ret = traits_type::to_int_type(*this->gptr()); } else __ret = this->pbackfail(); return __ret; } # 430 "/usr/include/c++/10/streambuf" 3 int_type sputc(char_type __c) { int_type __ret; if (__builtin_expect(this->pptr() < this->epptr(), true)) { *this->pptr() = __c; this->pbump(1); __ret = traits_type::to_int_type(__c); } else __ret = this->overflow(traits_type::to_int_type(__c)); return __ret; } # 456 "/usr/include/c++/10/streambuf" 3 streamsize sputn(const char_type* __s, streamsize __n) { return this->xsputn(__s, __n); } protected: # 470 "/usr/include/c++/10/streambuf" 3 basic_streambuf() : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), _M_out_beg(0), _M_out_cur(0), _M_out_end(0), _M_buf_locale(locale()) { } # 488 "/usr/include/c++/10/streambuf" 3 char_type* eback() const { return _M_in_beg; } char_type* gptr() const { return _M_in_cur; } char_type* egptr() const { return _M_in_end; } # 504 "/usr/include/c++/10/streambuf" 3 void gbump(int __n) { _M_in_cur += __n; } # 515 "/usr/include/c++/10/streambuf" 3 void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) { _M_in_beg = __gbeg; _M_in_cur = __gnext; _M_in_end = __gend; } # 535 "/usr/include/c++/10/streambuf" 3 char_type* pbase() const { return _M_out_beg; } char_type* pptr() const { return _M_out_cur; } char_type* epptr() const { return _M_out_end; } # 551 "/usr/include/c++/10/streambuf" 3 void pbump(int __n) { _M_out_cur += __n; } # 561 "/usr/include/c++/10/streambuf" 3 void setp(char_type* __pbeg, char_type* __pend) { _M_out_beg = _M_out_cur = __pbeg; _M_out_end = __pend; } # 582 "/usr/include/c++/10/streambuf" 3 virtual void imbue(const locale& __loc __attribute__ ((__unused__))) { } # 597 "/usr/include/c++/10/streambuf" 3 virtual basic_streambuf* setbuf(char_type*, streamsize) { return this; } # 608 "/usr/include/c++/10/streambuf" 3 virtual pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out) { return pos_type(off_type(-1)); } # 620 "/usr/include/c++/10/streambuf" 3 virtual pos_type seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out) { return pos_type(off_type(-1)); } # 633 "/usr/include/c++/10/streambuf" 3 virtual int sync() { return 0; } # 655 "/usr/include/c++/10/streambuf" 3 virtual streamsize showmanyc() { return 0; } # 671 "/usr/include/c++/10/streambuf" 3 virtual streamsize xsgetn(char_type* __s, streamsize __n); # 693 "/usr/include/c++/10/streambuf" 3 virtual int_type underflow() { return traits_type::eof(); } # 706 "/usr/include/c++/10/streambuf" 3 virtual int_type uflow() { int_type __ret = traits_type::eof(); const bool __testeof = traits_type::eq_int_type(this->underflow(), __ret); if (!__testeof) { __ret = traits_type::to_int_type(*this->gptr()); this->gbump(1); } return __ret; } # 730 "/usr/include/c++/10/streambuf" 3 virtual int_type pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) { return traits_type::eof(); } # 748 "/usr/include/c++/10/streambuf" 3 virtual streamsize xsputn(const char_type* __s, streamsize __n); # 774 "/usr/include/c++/10/streambuf" 3 virtual int_type overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) { return traits_type::eof(); } # 801 "/usr/include/c++/10/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 std::basic_streambuf<_CharT, _Traits>:: basic_streambuf(const basic_streambuf&) = default; template std::basic_streambuf<_CharT, _Traits>& std::basic_streambuf<_CharT, _Traits>:: operator=(const basic_streambuf&) = default; template<> streamsize __copy_streambufs_eof(basic_streambuf* __sbin, basic_streambuf* __sbout, bool& __ineof); template<> streamsize __copy_streambufs_eof(basic_streambuf* __sbin, basic_streambuf* __sbout, bool& __ineof); } # 1 "/usr/include/c++/10/bits/streambuf.tcc" 1 3 # 37 "/usr/include/c++/10/bits/streambuf.tcc" 3 # 38 "/usr/include/c++/10/bits/streambuf.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template 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 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 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 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; extern template streamsize __copy_streambufs(basic_streambuf*, basic_streambuf*); extern template streamsize __copy_streambufs_eof(basic_streambuf*, basic_streambuf*, bool&); extern template class basic_streambuf; extern template streamsize __copy_streambufs(basic_streambuf*, basic_streambuf*); extern template streamsize __copy_streambufs_eof(basic_streambuf*, basic_streambuf*, bool&); } # 861 "/usr/include/c++/10/streambuf" 2 3 # 36 "/usr/include/c++/10/bits/streambuf_iterator.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 49 "/usr/include/c++/10/bits/streambuf_iterator.h" 3 template class istreambuf_iterator : public iterator { public: # 63 "/usr/include/c++/10/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 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 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, _CharT2*>::__type __copy_move_a2(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, _CharT2*); template friend __enable_if_t<__is_char<_CharT2>::__value, _CharT2*> __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*); template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, istreambuf_iterator<_CharT2> >::__type find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, const _CharT2&); template 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; char_type operator*() const { int_type __c = _M_get(); # 157 "/usr/include/c++/10/bits/streambuf_iterator.h" 3 return traits_type::to_char_type(__c); } istreambuf_iterator& operator++() { ; _M_sbuf->sbumpc(); _M_c = traits_type::eof(); return *this; } istreambuf_iterator operator++(int) { ; istreambuf_iterator __old = *this; __old._M_c = _M_sbuf->sbumpc(); _M_c = traits_type::eof(); return __old; } bool equal(const istreambuf_iterator& __b) const { return _M_at_eof() == __b._M_at_eof(); } private: int_type _M_get() const { int_type __ret = _M_c; if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc())) _M_sbuf = 0; return __ret; } bool _M_at_eof() const { return _S_is_eof(_M_get()); } static bool _S_is_eof(int_type __c) { const int_type __eof = traits_type::eof(); return traits_type::eq_int_type(__c, __eof); } friend bool operator==(const istreambuf_iterator& __i, default_sentinel_t __s) { return __i._M_at_eof(); } }; template inline bool operator==(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) { return __a.equal(__b); } template inline bool operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) { return !__a.equal(__b); } template class ostreambuf_iterator : public iterator { 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; template friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, ostreambuf_iterator<_CharT2> >::__type copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, ostreambuf_iterator<_CharT2>); private: streambuf_type* _M_sbuf; bool _M_failed; public: 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; } ostreambuf_iterator& operator*() { return *this; } ostreambuf_iterator& operator++(int) { return *this; } ostreambuf_iterator& operator++() { return *this; } bool failed() const noexcept { return _M_failed; } ostreambuf_iterator& _M_put(const _CharT* __ws, streamsize __len) { if (__builtin_expect(!_M_failed, true) && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, false)) _M_failed = true; return *this; } }; template typename __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 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 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 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 __enable_if_t<__is_char<_CharT>::__value, _CharT*> __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result) { if (__n == 0) return __result; ; _CharT* __beg = __result; __result += __it._M_sbuf->sgetn(__beg, __n); ; return __result; } template typename __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 __gnu_cxx::__enable_if<__is_char<_CharT>::__value, void>::__type advance(istreambuf_iterator<_CharT>& __i, _Distance __n) { if (__n == 0) return; ; ; typedef istreambuf_iterator<_CharT> __is_iterator_type; typedef typename __is_iterator_type::traits_type traits_type; typedef typename __is_iterator_type::streambuf_type streambuf_type; typedef typename traits_type::int_type int_type; const int_type __eof = traits_type::eof(); streambuf_type* __sb = __i._M_sbuf; while (__n > 0) { streamsize __size = __sb->egptr() - __sb->gptr(); if (__size > __n) { __sb->__safe_gbump(__n); break; } __sb->__safe_gbump(__size); __n -= __size; if (traits_type::eq_int_type(__sb->underflow(), __eof)) { ; break; } } __i._M_c = __eof; } } # 67 "/usr/include/c++/10/iterator" 2 3 # 37 "/usr/include/c++/10/bits/ranges_algobase.h" 2 3 # 1 "/usr/include/c++/10/ranges" 1 3 # 35 "/usr/include/c++/10/ranges" 3 # 36 "/usr/include/c++/10/ranges" 3 # 54 "/usr/include/c++/10/ranges" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace ranges { struct view_base { }; template inline constexpr bool enable_view = derived_from<_Tp, view_base>; template concept view = range<_Tp> && movable<_Tp> && default_initializable<_Tp> && enable_view<_Tp>; template concept viewable_range = range<_Tp> && (borrowed_range<_Tp> || view>); namespace __detail { template concept __simple_view = view<_Range> && range && same_as, iterator_t> && same_as, sentinel_t>; template concept __has_arrow = input_iterator<_It> && (is_pointer_v<_It> || requires(_It __it) { __it.operator->(); }); template concept __not_same_as = !same_as, remove_cvref_t<_Up>>; } template requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>> class view_interface : public view_base { 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(*this); } public: constexpr bool empty() requires forward_range<_Derived> { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); } constexpr bool empty() const requires forward_range { return ranges::begin(_M_derived()) == ranges::end(_M_derived()); } constexpr explicit operator bool() requires requires { ranges::empty(_M_derived()); } { return !ranges::empty(_M_derived()); } constexpr explicit operator bool() const requires requires { ranges::empty(_M_derived()); } { return !ranges::empty(_M_derived()); } constexpr auto data() requires contiguous_iterator> { return to_address(ranges::begin(_M_derived())); } constexpr auto data() const requires range && contiguous_iterator> { return to_address(ranges::begin(_M_derived())); } constexpr auto size() requires forward_range<_Derived> && sized_sentinel_for, iterator_t<_Derived>> { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); } constexpr auto size() const requires forward_range && sized_sentinel_for, iterator_t> { return ranges::end(_M_derived()) - ranges::begin(_M_derived()); } constexpr decltype(auto) front() requires forward_range<_Derived> { ; return *ranges::begin(_M_derived()); } constexpr decltype(auto) front() const requires forward_range { ; return *ranges::begin(_M_derived()); } constexpr decltype(auto) back() requires bidirectional_range<_Derived> && common_range<_Derived> { ; return *ranges::prev(ranges::end(_M_derived())); } constexpr decltype(auto) back() const requires bidirectional_range && common_range { ; return *ranges::prev(ranges::end(_M_derived())); } template constexpr decltype(auto) operator[](range_difference_t<_Range> __n) { return ranges::begin(_M_derived())[__n]; } template constexpr decltype(auto) operator[](range_difference_t<_Range> __n) const { return ranges::begin(_M_derived())[__n]; } }; namespace __detail { template concept __convertible_to_non_slicing = convertible_to<_From, _To> && !(is_pointer_v> && is_pointer_v> && __not_same_as>, remove_pointer_t>>); template concept __pair_like = !is_reference_v<_Tp> && requires(_Tp __t) { typename tuple_size<_Tp>::type; requires derived_from, integral_constant>; typename tuple_element_t<0, remove_const_t<_Tp>>; typename tuple_element_t<1, remove_const_t<_Tp>>; { get<0>(__t) } -> convertible_to&>; { get<1>(__t) } -> convertible_to&>; }; template concept __pair_like_convertible_from = !range<_Tp> && __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>>; template concept __iterator_sentinel_pair = !range<_Tp> && __pair_like<_Tp> && sentinel_for, tuple_element_t<0, _Tp>>; } enum class subrange_kind : bool { unsized, sized }; template _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> { private: static const bool _S_store_size = _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>; _It _M_begin = _It(); _Sent _M_end = _Sent(); template struct _Size { }; template struct _Size<_Tp, true> { __detail::__make_unsigned_like_t<_Tp> _M_size; }; [[no_unique_address]] _Size> _M_size = {}; public: subrange() = default; constexpr subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s) requires (!_S_store_size) : _M_begin(std::move(__i)), _M_end(__s) { } constexpr subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s, __detail::__make_unsigned_like_t> __n) requires (_Kind == subrange_kind::sized) : _M_begin(std::move(__i)), _M_end(__s) { using __detail::__to_unsigned_like; ; if constexpr (_S_store_size) _M_size._M_size = __n; } template<__detail::__not_same_as _Rng> requires borrowed_range<_Rng> && __detail::__convertible_to_non_slicing, _It> && convertible_to, _Sent> constexpr subrange(_Rng&& __r) requires _S_store_size && sized_range<_Rng> : subrange(__r, ranges::size(__r)) { } template<__detail::__not_same_as _Rng> requires borrowed_range<_Rng> && __detail::__convertible_to_non_slicing, _It> && convertible_to, _Sent> constexpr subrange(_Rng&& __r) requires (!_S_store_size) : subrange{ranges::begin(__r), ranges::end(__r)} { } template requires __detail::__convertible_to_non_slicing, _It> && convertible_to, _Sent> constexpr subrange(_Rng&& __r, __detail::__make_unsigned_like_t> __n) requires (_Kind == subrange_kind::sized) : subrange{ranges::begin(__r), ranges::end(__r), __n} { } template<__detail::__not_same_as _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 __detail::__make_unsigned_like_t> 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; } ; 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 _Sent> subrange(_It, _Sent) -> subrange<_It, _Sent>; template _Sent> subrange(_It, _Sent, __detail::__make_unsigned_like_t>) -> subrange<_It, _Sent, subrange_kind::sized>; template<__detail::__iterator_sentinel_pair _Pr> subrange(_Pr) -> subrange, tuple_element_t<1, _Pr>>; template<__detail::__iterator_sentinel_pair _Pr> subrange(_Pr, __detail::__make_unsigned_like_t>>) -> subrange, tuple_element_t<1, _Pr>, subrange_kind::sized>; template subrange(_Rng&&) -> subrange, sentinel_t<_Rng>, (sized_range<_Rng> || sized_sentinel_for, iterator_t<_Rng>>) ? subrange_kind::sized : subrange_kind::unsized>; template subrange(_Rng&&, __detail::__make_unsigned_like_t>) -> subrange, sentinel_t<_Rng>, subrange_kind::sized>; template requires (_Num < 2) constexpr auto get(const subrange<_It, _Sent, _Kind>& __r) { if constexpr (_Num == 0) return __r.begin(); else return __r.end(); } template requires (_Num < 2) constexpr auto get(subrange<_It, _Sent, _Kind>&& __r) { if constexpr (_Num == 0) return __r.begin(); else return __r.end(); } template _Sent, subrange_kind _Kind> inline constexpr bool enable_borrowed_range> = true; } using ranges::get; namespace ranges { struct dangling { constexpr dangling() noexcept = default; template constexpr dangling(_Args&&...) noexcept { } }; template using borrowed_iterator_t = conditional_t, iterator_t<_Range>, dangling>; template using borrowed_subrange_t = conditional_t, subrange>, dangling>; template requires is_object_v<_Tp> class empty_view : public view_interface> { public: static constexpr _Tp* begin() noexcept { return nullptr; } static constexpr _Tp* end() noexcept { return nullptr; } static constexpr _Tp* data() noexcept { return nullptr; } static constexpr size_t size() noexcept { return 0; } static constexpr bool empty() noexcept { return true; } }; template inline constexpr bool enable_borrowed_range> = true; namespace __detail { template requires is_object_v<_Tp> struct __box : std::optional<_Tp> { using std::optional<_Tp>::optional; constexpr __box() noexcept(is_nothrow_default_constructible_v<_Tp>) requires default_initializable<_Tp> : std::optional<_Tp>{std::in_place} { } __box(const __box&) = default; __box(__box&&) = default; using std::optional<_Tp>::operator=; __box& operator=(const __box& __that) noexcept(is_nothrow_copy_constructible_v<_Tp>) requires (!copyable<_Tp>) { if ((bool)__that) this->emplace(*__that); else this->reset(); return *this; } __box& operator=(__box&& __that) noexcept(is_nothrow_move_constructible_v<_Tp>) requires (!movable<_Tp>) { if ((bool)__that) this->emplace(std::move(*__that)); else this->reset(); return *this; } }; } template requires is_object_v<_Tp> class single_view : public view_interface> { public: single_view() = default; constexpr explicit single_view(const _Tp& __t) : _M_value(__t) { } constexpr explicit single_view(_Tp&& __t) : _M_value(std::move(__t)) { } template requires constructible_from<_Tp, _Args...> constexpr explicit single_view(in_place_t, _Args&&... __args) : _M_value{in_place, std::forward<_Args>(__args)...} { } constexpr _Tp* begin() noexcept { return data(); } constexpr const _Tp* begin() const noexcept { return data(); } constexpr _Tp* end() noexcept { return data() + 1; } constexpr const _Tp* end() const noexcept { return data() + 1; } static constexpr size_t size() noexcept { return 1; } constexpr _Tp* data() noexcept { return _M_value.operator->(); } constexpr const _Tp* data() const noexcept { return _M_value.operator->(); } private: __detail::__box<_Tp> _M_value; }; namespace __detail { template constexpr auto __to_signed_like(_Wp __w) noexcept { if constexpr (!integral<_Wp>) return iter_difference_t<_Wp>(); else if constexpr (sizeof(iter_difference_t<_Wp>) > sizeof(_Wp)) return iter_difference_t<_Wp>(__w); else if constexpr (sizeof(ptrdiff_t) > sizeof(_Wp)) return ptrdiff_t(__w); else if constexpr (sizeof(long long) > sizeof(_Wp)) return (long long)(__w); else if constexpr (16 > sizeof(_Wp)) return __int128(__w); else return __max_diff_type(__w); } template using __iota_diff_t = decltype(__to_signed_like(std::declval<_Wp>())); template concept __decrementable = incrementable<_It> && requires(_It __i) { { --__i } -> same_as<_It&>; { __i-- } -> same_as<_It>; }; template concept __advanceable = __decrementable<_It> && totally_ordered<_It> && requires( _It __i, const _It __j, const __iota_diff_t<_It> __n) { { __i += __n } -> same_as<_It&>; { __i -= __n } -> same_as<_It&>; _It(__j + __n); _It(__n + __j); _It(__j - __n); { __j - __j } -> convertible_to<__iota_diff_t<_It>>; }; } template requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound> && semiregular<_Winc> class iota_view : public view_interface> { private: struct _Sentinel; struct _Iterator { private: static auto _S_iter_cat() { using namespace __detail; if constexpr (__advanceable<_Winc>) return random_access_iterator_tag{}; else if constexpr (__decrementable<_Winc>) return bidirectional_iterator_tag{}; else if constexpr (incrementable<_Winc>) return forward_iterator_tag{}; else return input_iterator_tag{}; } public: using iterator_category = decltype(_S_iter_cat()); using value_type = _Winc; using difference_type = __detail::__iota_diff_t<_Winc>; _Iterator() = default; constexpr explicit _Iterator(_Winc __value) : _M_value(__value) { } constexpr _Winc operator*() const noexcept(is_nothrow_copy_constructible_v<_Winc>) { return _M_value; } constexpr _Iterator& operator++() { ++_M_value; return *this; } constexpr void operator++(int) { ++*this; } constexpr _Iterator operator++(int) requires incrementable<_Winc> { auto __tmp = *this; ++*this; return __tmp; } constexpr _Iterator& operator--() requires __detail::__decrementable<_Winc> { --_M_value; return *this; } constexpr _Iterator operator--(int) requires __detail::__decrementable<_Winc> { auto __tmp = *this; --*this; return __tmp; } constexpr _Iterator& operator+=(difference_type __n) requires __detail::__advanceable<_Winc> { using __detail::__is_integer_like; using __detail::__is_signed_integer_like; if constexpr (__is_integer_like<_Winc> && !__is_signed_integer_like<_Winc>) { if (__n >= difference_type(0)) _M_value += static_cast<_Winc>(__n); else _M_value -= static_cast<_Winc>(-__n); } else _M_value += __n; return *this; } constexpr _Iterator& operator-=(difference_type __n) requires __detail::__advanceable<_Winc> { using __detail::__is_integer_like; using __detail::__is_signed_integer_like; if constexpr (__is_integer_like<_Winc> && !__is_signed_integer_like<_Winc>) { if (__n >= difference_type(0)) _M_value -= static_cast<_Winc>(__n); else _M_value += static_cast<_Winc>(-__n); } else _M_value -= __n; return *this; } constexpr _Winc operator[](difference_type __n) const requires __detail::__advanceable<_Winc> { return _Winc(_M_value + __n); } friend constexpr bool operator==(const _Iterator& __x, const _Iterator& __y) requires equality_comparable<_Winc> { return __x._M_value == __y._M_value; } friend constexpr bool operator<(const _Iterator& __x, const _Iterator& __y) requires totally_ordered<_Winc> { return __x._M_value < __y._M_value; } friend constexpr bool operator>(const _Iterator& __x, const _Iterator& __y) requires totally_ordered<_Winc> { return __y < __x; } friend constexpr bool operator<=(const _Iterator& __x, const _Iterator& __y) requires totally_ordered<_Winc> { return !(__y < __x); } friend constexpr bool operator>=(const _Iterator& __x, const _Iterator& __y) requires totally_ordered<_Winc> { return !(__x < __y); } friend constexpr auto operator<=>(const _Iterator& __x, const _Iterator& __y) requires totally_ordered<_Winc> && three_way_comparable<_Winc> { return __x._M_value <=> __y._M_value; } friend constexpr _Iterator operator+(_Iterator __i, difference_type __n) requires __detail::__advanceable<_Winc> { return __i += __n; } friend constexpr _Iterator operator+(difference_type __n, _Iterator __i) requires __detail::__advanceable<_Winc> { return __i += __n; } friend constexpr _Iterator operator-(_Iterator __i, difference_type __n) requires __detail::__advanceable<_Winc> { return __i -= __n; } friend constexpr difference_type operator-(const _Iterator& __x, const _Iterator& __y) requires __detail::__advanceable<_Winc> { using __detail::__is_integer_like; using __detail::__is_signed_integer_like; using _Dt = difference_type; if constexpr (__is_integer_like<_Winc>) { if constexpr (__is_signed_integer_like<_Winc>) return _Dt(_Dt(__x._M_value) - _Dt(__y._M_value)); else return (__y._M_value > __x._M_value) ? _Dt(-_Dt(__y._M_value - __x._M_value)) : _Dt(__x._M_value - __y._M_value); } else return __x._M_value - __y._M_value; } private: _Winc _M_value = _Winc(); friend _Sentinel; }; struct _Sentinel { private: constexpr bool _M_equal(const _Iterator& __x) const { return __x._M_value == _M_bound; } _Bound _M_bound = _Bound(); public: _Sentinel() = default; constexpr explicit _Sentinel(_Bound __bound) : _M_bound(__bound) { } friend constexpr bool operator==(const _Iterator& __x, const _Sentinel& __y) { return __y._M_equal(__x); } friend constexpr iter_difference_t<_Winc> operator-(const _Iterator& __x, const _Sentinel& __y) requires sized_sentinel_for<_Bound, _Winc> { return __x._M_value - __y._M_bound; } friend constexpr iter_difference_t<_Winc> operator-(const _Sentinel& __x, const _Iterator& __y) requires sized_sentinel_for<_Bound, _Winc> { return -(__y - __x); } }; _Winc _M_value = _Winc(); _Bound _M_bound = _Bound(); public: iota_view() = default; constexpr explicit iota_view(_Winc __value) : _M_value(__value) { } constexpr iota_view(type_identity_t<_Winc> __value, type_identity_t<_Bound> __bound) : _M_value(__value), _M_bound(__bound) { if constexpr (totally_ordered_with<_Winc, _Bound>) { ; } } constexpr _Iterator begin() const { return _Iterator{_M_value}; } constexpr auto end() const { if constexpr (same_as<_Bound, unreachable_sentinel_t>) return unreachable_sentinel; else return _Sentinel{_M_bound}; } constexpr _Iterator end() const requires same_as<_Winc, _Bound> { return _Iterator{_M_bound}; } constexpr auto size() const requires (same_as<_Winc, _Bound> && __detail::__advanceable<_Winc>) || (integral<_Winc> && integral<_Bound>) || sized_sentinel_for<_Bound, _Winc> { using __detail::__is_integer_like; using __detail::__to_unsigned_like; if constexpr (integral<_Winc> && integral<_Bound>) { using _Up = make_unsigned_t; return _Up(_M_bound) - _Up(_M_value); } else if constexpr (__is_integer_like<_Winc>) return __to_unsigned_like(_M_bound) - __to_unsigned_like(_M_value); else return __to_unsigned_like(_M_bound - _M_value); } }; template requires (!__detail::__is_integer_like<_Winc> || !__detail::__is_integer_like<_Bound> || (__detail::__is_signed_integer_like<_Winc> == __detail::__is_signed_integer_like<_Bound>)) iota_view(_Winc, _Bound) -> iota_view<_Winc, _Bound>; template inline constexpr bool enable_borrowed_range> = true; namespace views { template inline constexpr empty_view<_Tp> empty{}; struct _Single { template constexpr auto operator()(_Tp&& __e) const { return single_view{std::forward<_Tp>(__e)}; } }; inline constexpr _Single single{}; struct _Iota { template constexpr auto operator()(_Tp&& __e) const { return iota_view{std::forward<_Tp>(__e)}; } template constexpr auto operator()(_Tp&& __e, _Up&& __f) const { return iota_view{std::forward<_Tp>(__e), std::forward<_Up>(__f)}; } }; inline constexpr _Iota iota{}; } namespace __detail { template concept __stream_extractable = requires(basic_istream<_CharT, _Traits>& is, _Val& t) { is >> t; }; } template requires default_initializable<_Val> && __detail::__stream_extractable<_Val, _CharT, _Traits> class basic_istream_view : public view_interface> { public: basic_istream_view() = default; constexpr explicit basic_istream_view(basic_istream<_CharT, _Traits>& __stream) : _M_stream(std::__addressof(__stream)) { } constexpr auto begin() { if (_M_stream != nullptr) *_M_stream >> _M_object; return _Iterator{*this}; } constexpr default_sentinel_t end() const noexcept { return default_sentinel; } private: basic_istream<_CharT, _Traits>* _M_stream = nullptr; _Val _M_object = _Val(); struct _Iterator { public: using iterator_concept = input_iterator_tag; using difference_type = ptrdiff_t; using value_type = _Val; _Iterator() = default; constexpr explicit _Iterator(basic_istream_view& __parent) noexcept : _M_parent(std::__addressof(__parent)) { } _Iterator(const _Iterator&) = delete; _Iterator(_Iterator&&) = default; _Iterator& operator=(const _Iterator&) = delete; _Iterator& operator=(_Iterator&&) = default; _Iterator& operator++() { ; *_M_parent->_M_stream >> _M_parent->_M_object; return *this; } void operator++(int) { ++*this; } _Val& operator*() const { ; return _M_parent->_M_object; } friend bool operator==(const _Iterator& __x, default_sentinel_t) { return __x._M_at_end(); } private: basic_istream_view* _M_parent = nullptr; bool _M_at_end() const { return _M_parent == nullptr || !*_M_parent->_M_stream; } }; friend _Iterator; }; template basic_istream_view<_Val, _CharT, _Traits> istream_view(basic_istream<_CharT, _Traits>& __s) { return basic_istream_view<_Val, _CharT, _Traits>{__s}; } namespace __detail { struct _Empty { }; template using __maybe_present_t = conditional_t<_Present, _Tp, _Empty>; template using __maybe_const_t = conditional_t<_Const, const _Tp, _Tp>; } namespace views { namespace __adaptor { template inline constexpr auto __maybe_refwrap(_Tp& __arg) { return reference_wrapper<_Tp>{__arg}; } template inline constexpr auto __maybe_refwrap(const _Tp& __arg) { return reference_wrapper{__arg}; } template inline constexpr decltype(auto) __maybe_refwrap(_Tp&& __arg) { return std::forward<_Tp>(__arg); } template struct _RangeAdaptorClosure; template struct _RangeAdaptor { protected: [[no_unique_address]] __detail::__maybe_present_t, _Callable> _M_callable; public: constexpr _RangeAdaptor(const _Callable& = {}) requires is_default_constructible_v<_Callable> { } constexpr _RangeAdaptor(_Callable __callable) requires (!is_default_constructible_v<_Callable>) : _M_callable(std::move(__callable)) { } template requires (sizeof...(_Args) >= 1) constexpr auto operator()(_Args&&... __args) const { # 1120 "/usr/include/c++/10/ranges" 3 if constexpr (is_invocable_v<_Callable, _Args...>) { static_assert(sizeof...(_Args) != 1, "a _RangeAdaptor that accepts only one argument " "should be defined as a _RangeAdaptorClosure"); return _Callable{}(std::forward<_Args>(__args)...); } else { # 1139 "/usr/include/c++/10/ranges" 3 auto __closure = [...__args(__maybe_refwrap(std::forward<_Args>(__args)))] (_Range&& __r) { return _Callable{}(std::forward<_Range>(__r), (static_cast>> (__args))...); }; using _ClosureType = decltype(__closure); return _RangeAdaptorClosure<_ClosureType>(std::move(__closure)); } } }; template _RangeAdaptor(_Callable) -> _RangeAdaptor<_Callable>; template struct _RangeAdaptorClosure : public _RangeAdaptor<_Callable> { using _RangeAdaptor<_Callable>::_RangeAdaptor; template requires requires { declval<_Callable>()(declval<_Range>()); } constexpr auto operator()(_Range&& __r) const { if constexpr (is_default_constructible_v<_Callable>) return _Callable{}(std::forward<_Range>(__r)); else return this->_M_callable(std::forward<_Range>(__r)); } template requires requires { declval<_Callable>()(declval<_Range>()); } friend constexpr auto operator|(_Range&& __r, const _RangeAdaptorClosure& __o) { return __o(std::forward<_Range>(__r)); } template friend constexpr auto operator|(const _RangeAdaptorClosure<_Tp>& __x, const _RangeAdaptorClosure& __y) { if constexpr (is_default_constructible_v<_Tp> && is_default_constructible_v<_Callable>) { auto __closure = [] (_Up&& __e) { return std::forward<_Up>(__e) | decltype(__x){} | decltype(__y){}; }; return _RangeAdaptorClosure(__closure); } else if constexpr (is_default_constructible_v<_Tp> && !is_default_constructible_v<_Callable>) { auto __closure = [__y] (_Up&& __e) { return std::forward<_Up>(__e) | decltype(__x){} | __y; }; return _RangeAdaptorClosure(__closure); } else if constexpr (!is_default_constructible_v<_Tp> && is_default_constructible_v<_Callable>) { auto __closure = [__x] (_Up&& __e) { return std::forward<_Up>(__e) | __x | decltype(__y){}; }; return _RangeAdaptorClosure(__closure); } else { auto __closure = [__x, __y] (_Up&& __e) { return std::forward<_Up>(__e) | __x | __y; }; return _RangeAdaptorClosure(__closure); } } }; template _RangeAdaptorClosure(_Callable) -> _RangeAdaptorClosure<_Callable>; } } template requires is_object_v<_Range> class ref_view : public view_interface> { private: _Range* _M_r = nullptr; static void _S_fun(_Range&); static void _S_fun(_Range&&) = delete; public: constexpr ref_view() noexcept = default; template<__detail::__not_same_as _Tp> requires convertible_to<_Tp, _Range&> && requires { _S_fun(declval<_Tp>()); } constexpr ref_view(_Tp&& __t) : _M_r(std::__addressof(static_cast<_Range&>(std::forward<_Tp>(__t)))) { } constexpr _Range& base() const { return *_M_r; } constexpr iterator_t<_Range> begin() const { return ranges::begin(*_M_r); } constexpr sentinel_t<_Range> end() const { return ranges::end(*_M_r); } constexpr bool empty() const requires requires { ranges::empty(*_M_r); } { return ranges::empty(*_M_r); } constexpr auto size() const requires sized_range<_Range> { return ranges::size(*_M_r); } constexpr auto data() const requires contiguous_range<_Range> { return ranges::data(*_M_r); } }; template ref_view(_Range&) -> ref_view<_Range>; template inline constexpr bool enable_borrowed_range> = true; namespace views { inline constexpr __adaptor::_RangeAdaptorClosure all = [] (_Range&& __r) { if constexpr (view>) return std::forward<_Range>(__r); else if constexpr (requires { ref_view{std::forward<_Range>(__r)}; }) return ref_view{std::forward<_Range>(__r)}; else return subrange{std::forward<_Range>(__r)}; }; template using all_t = decltype(all(std::declval<_Range>())); } namespace __detail { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr _Iter find_if(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) { while (__first != __last && !(bool)std::__invoke(__pred, std::__invoke(__proj, *__first))) ++__first; return __first; } template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr _Iter find_if_not(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) { while (__first != __last && (bool)std::__invoke(__pred, std::__invoke(__proj, *__first))) ++__first; return __first; } template> _Comp = ranges::less> constexpr const _Tp& min(const _Tp& __a, const _Tp& __b, _Comp __comp = {}, _Proj __proj = {}) { if (std::__invoke(std::move(__comp), std::__invoke(__proj, __b), std::__invoke(__proj, __a))) return __b; else return __a; } template _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 pair<_Iter1, _Iter2> mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) { 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) }; } } namespace __detail { template struct _CachedPosition { constexpr bool _M_has_value() const { return false; } constexpr iterator_t<_Range> _M_get(const _Range&) const { ; return {}; } constexpr void _M_set(const _Range&, const iterator_t<_Range>&) const { } }; template struct _CachedPosition<_Range> { private: iterator_t<_Range> _M_iter{}; public: constexpr bool _M_has_value() const { return _M_iter != iterator_t<_Range>{}; } constexpr iterator_t<_Range> _M_get(const _Range&) const { ; return _M_iter; } constexpr void _M_set(const _Range&, const iterator_t<_Range>& __it) { ; _M_iter = __it; } }; template requires (sizeof(range_difference_t<_Range>) <= sizeof(iterator_t<_Range>)) struct _CachedPosition<_Range> { private: range_difference_t<_Range> _M_offset = -1; public: constexpr bool _M_has_value() const { return _M_offset >= 0; } constexpr iterator_t<_Range> _M_get(_Range& __r) const { ; return ranges::begin(__r) + _M_offset; } constexpr void _M_set(_Range& __r, const iterator_t<_Range>& __it) { ; _M_offset = __it - ranges::begin(__r); } }; } template> _Pred> requires view<_Vp> && is_object_v<_Pred> class filter_view : public view_interface> { private: struct _Sentinel; struct _Iterator { private: static constexpr auto _S_iter_concept() { if constexpr (bidirectional_range<_Vp>) return bidirectional_iterator_tag{}; else if constexpr (forward_range<_Vp>) return forward_iterator_tag{}; else return input_iterator_tag{}; } static constexpr auto _S_iter_cat() { using _Cat = typename iterator_traits<_Vp_iter>::iterator_category; if constexpr (derived_from<_Cat, bidirectional_iterator_tag>) return bidirectional_iterator_tag{}; else if constexpr (derived_from<_Cat, forward_iterator_tag>) return forward_iterator_tag{}; else return _Cat{}; } friend filter_view; using _Vp_iter = iterator_t<_Vp>; _Vp_iter _M_current = _Vp_iter(); filter_view* _M_parent = nullptr; public: using iterator_concept = decltype(_S_iter_concept()); using iterator_category = decltype(_S_iter_cat()); using value_type = range_value_t<_Vp>; using difference_type = range_difference_t<_Vp>; _Iterator() = default; constexpr _Iterator(filter_view& __parent, _Vp_iter __current) : _M_current(std::move(__current)), _M_parent(std::__addressof(__parent)) { } constexpr _Vp_iter base() const & requires copyable<_Vp_iter> { return _M_current; } constexpr _Vp_iter base() && { return std::move(_M_current); } constexpr range_reference_t<_Vp> operator*() const { return *_M_current; } constexpr _Vp_iter operator->() const requires __detail::__has_arrow<_Vp_iter> && copyable<_Vp_iter> { return _M_current; } constexpr _Iterator& operator++() { _M_current = __detail::find_if(std::move(++_M_current), ranges::end(_M_parent->_M_base), std::ref(*_M_parent->_M_pred)); return *this; } constexpr void operator++(int) { ++*this; } constexpr _Iterator operator++(int) requires forward_range<_Vp> { auto __tmp = *this; ++*this; return __tmp; } constexpr _Iterator& operator--() requires bidirectional_range<_Vp> { do --_M_current; while (!std::__invoke(*_M_parent->_M_pred, *_M_current)); return *this; } constexpr _Iterator operator--(int) requires bidirectional_range<_Vp> { auto __tmp = *this; --*this; return __tmp; } friend constexpr bool operator==(const _Iterator& __x, const _Iterator& __y) requires equality_comparable<_Vp_iter> { return __x._M_current == __y._M_current; } friend constexpr range_rvalue_reference_t<_Vp> iter_move(const _Iterator& __i) noexcept(noexcept(ranges::iter_move(__i._M_current))) { return ranges::iter_move(__i._M_current); } friend constexpr void iter_swap(const _Iterator& __x, const _Iterator& __y) noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current))) requires indirectly_swappable<_Vp_iter> { ranges::iter_swap(__x._M_current, __y._M_current); } }; struct _Sentinel { private: sentinel_t<_Vp> _M_end = sentinel_t<_Vp>(); constexpr bool __equal(const _Iterator& __i) const { return __i._M_current == _M_end; } public: _Sentinel() = default; constexpr explicit _Sentinel(filter_view& __parent) : _M_end(ranges::end(__parent._M_base)) { } constexpr sentinel_t<_Vp> base() const { return _M_end; } friend constexpr bool operator==(const _Iterator& __x, const _Sentinel& __y) { return __y.__equal(__x); } }; _Vp _M_base = _Vp(); __detail::__box<_Pred> _M_pred; [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin; public: filter_view() = default; constexpr filter_view(_Vp __base, _Pred __pred) : _M_base(std::move(__base)), _M_pred(std::move(__pred)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr const _Pred& pred() const { return *_M_pred; } constexpr _Iterator begin() { if (_M_cached_begin._M_has_value()) return {*this, _M_cached_begin._M_get(_M_base)}; ; auto __it = __detail::find_if(ranges::begin(_M_base), ranges::end(_M_base), std::ref(*_M_pred)); _M_cached_begin._M_set(_M_base, __it); return {*this, std::move(__it)}; } constexpr auto end() { if constexpr (common_range<_Vp>) return _Iterator{*this, ranges::end(_M_base)}; else return _Sentinel{*this}; } }; template filter_view(_Range&&, _Pred) -> filter_view, _Pred>; namespace views { inline constexpr __adaptor::_RangeAdaptor filter = [] (_Range&& __r, _Pred&& __p) { return filter_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)}; }; } template requires view<_Vp> && is_object_v<_Fp> && regular_invocable<_Fp&, range_reference_t<_Vp>> && std::__detail::__can_reference>> class transform_view : public view_interface> { private: template struct _Sentinel; template struct _Iterator { private: using _Parent = __detail::__maybe_const_t<_Const, transform_view>; using _Base = __detail::__maybe_const_t<_Const, _Vp>; static constexpr auto _S_iter_concept() { if constexpr (random_access_range<_Vp>) return random_access_iterator_tag{}; else if constexpr (bidirectional_range<_Vp>) return bidirectional_iterator_tag{}; else if constexpr (forward_range<_Vp>) return forward_iterator_tag{}; else return input_iterator_tag{}; } static constexpr auto _S_iter_cat() { using _Res = invoke_result_t<_Fp&, range_reference_t<_Base>>; if constexpr (is_lvalue_reference_v<_Res>) { using _Cat = typename iterator_traits<_Base_iter>::iterator_category; if constexpr (derived_from<_Cat, contiguous_iterator_tag>) return random_access_iterator_tag{}; else return _Cat{}; } else return input_iterator_tag{}; } using _Base_iter = iterator_t<_Base>; _Base_iter _M_current = _Base_iter(); _Parent* _M_parent = nullptr; public: using iterator_concept = decltype(_S_iter_concept()); using iterator_category = decltype(_S_iter_cat()); using value_type = remove_cvref_t>>; using difference_type = range_difference_t<_Base>; _Iterator() = default; constexpr _Iterator(_Parent& __parent, _Base_iter __current) : _M_current(std::move(__current)), _M_parent(std::__addressof(__parent)) { } constexpr _Iterator(_Iterator __i) requires _Const && convertible_to, _Base_iter> : _M_current(std::move(__i._M_current)), _M_parent(__i._M_parent) { } constexpr _Base_iter base() const & requires copyable<_Base_iter> { return _M_current; } constexpr _Base_iter base() && { return std::move(_M_current); } constexpr decltype(auto) operator*() const noexcept(noexcept(std::__invoke(*_M_parent->_M_fun, *_M_current))) { return std::__invoke(*_M_parent->_M_fun, *_M_current); } constexpr _Iterator& operator++() { ++_M_current; return *this; } constexpr void operator++(int) { ++_M_current; } constexpr _Iterator operator++(int) requires forward_range<_Base> { auto __tmp = *this; ++*this; return __tmp; } constexpr _Iterator& operator--() requires bidirectional_range<_Base> { --_M_current; return *this; } constexpr _Iterator operator--(int) requires bidirectional_range<_Base> { auto __tmp = *this; --*this; return __tmp; } constexpr _Iterator& operator+=(difference_type __n) requires random_access_range<_Base> { _M_current += __n; return *this; } constexpr _Iterator& operator-=(difference_type __n) requires random_access_range<_Base> { _M_current -= __n; return *this; } constexpr decltype(auto) operator[](difference_type __n) const requires random_access_range<_Base> { return std::__invoke(*_M_parent->_M_fun, _M_current[__n]); } friend constexpr bool operator==(const _Iterator& __x, const _Iterator& __y) requires equality_comparable<_Base_iter> { return __x._M_current == __y._M_current; } friend constexpr bool operator<(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return __x._M_current < __y._M_current; } friend constexpr bool operator>(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return __y < __x; } friend constexpr bool operator<=(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return !(__y < __x); } friend constexpr bool operator>=(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return !(__x < __y); } friend constexpr auto operator<=>(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> && three_way_comparable<_Base_iter> { return __x._M_current <=> __y._M_current; } friend constexpr _Iterator operator+(_Iterator __i, difference_type __n) requires random_access_range<_Base> { return {*__i._M_parent, __i._M_current + __n}; } friend constexpr _Iterator operator+(difference_type __n, _Iterator __i) requires random_access_range<_Base> { return {*__i._M_parent, __i._M_current + __n}; } friend constexpr _Iterator operator-(_Iterator __i, difference_type __n) requires random_access_range<_Base> { return {*__i._M_parent, __i._M_current - __n}; } friend constexpr difference_type operator-(const _Iterator& __x, const _Iterator& __y) requires sized_sentinel_for, iterator_t<_Base>> { return __x._M_current - __y._M_current; } friend constexpr decltype(auto) iter_move(const _Iterator& __i) noexcept(noexcept(*__i)) { if constexpr (is_lvalue_reference_v) return std::move(*__i); else return *__i; } friend constexpr void iter_swap(const _Iterator& __x, const _Iterator& __y) noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current))) requires indirectly_swappable<_Base_iter> { return ranges::iter_swap(__x._M_current, __y._M_current); } friend _Iterator; template friend struct _Sentinel; }; template struct _Sentinel { private: using _Parent = __detail::__maybe_const_t<_Const, transform_view>; using _Base = __detail::__maybe_const_t<_Const, _Vp>; template constexpr auto __distance_from(const _Iterator<_Const2>& __i) const { return _M_end - __i._M_current; } template constexpr bool __equal(const _Iterator<_Const2>& __i) const { return __i._M_current == _M_end; } sentinel_t<_Base> _M_end = sentinel_t<_Base>(); public: _Sentinel() = default; constexpr explicit _Sentinel(sentinel_t<_Base> __end) : _M_end(__end) { } constexpr _Sentinel(_Sentinel __i) requires _Const && convertible_to, sentinel_t<_Base>> : _M_end(std::move(__i._M_end)) { } constexpr sentinel_t<_Base> base() const { return _M_end; } template requires sentinel_for, iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>> friend constexpr bool operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y) { return __y.__equal(__x); } template> requires sized_sentinel_for, iterator_t<_Base2>> friend constexpr range_difference_t<_Base2> operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y) { return -__y.__distance_from(__x); } template> requires sized_sentinel_for, iterator_t<_Base2>> friend constexpr range_difference_t<_Base2> operator-(const _Sentinel& __y, const _Iterator<_Const2>& __x) { return __y.__distance_from(__x); } friend _Sentinel; }; _Vp _M_base = _Vp(); __detail::__box<_Fp> _M_fun; public: transform_view() = default; constexpr transform_view(_Vp __base, _Fp __fun) : _M_base(std::move(__base)), _M_fun(std::move(__fun)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base ; } constexpr _Vp base() && { return std::move(_M_base); } constexpr _Iterator begin() { return _Iterator{*this, ranges::begin(_M_base)}; } constexpr _Iterator begin() const requires range && regular_invocable> { return _Iterator{*this, ranges::begin(_M_base)}; } constexpr _Sentinel end() { return _Sentinel{ranges::end(_M_base)}; } constexpr _Iterator end() requires common_range<_Vp> { return _Iterator{*this, ranges::end(_M_base)}; } constexpr _Sentinel end() const requires range && regular_invocable> { return _Sentinel{ranges::end(_M_base)}; } constexpr _Iterator end() const requires common_range && regular_invocable> { return _Iterator{*this, ranges::end(_M_base)}; } constexpr auto size() requires sized_range<_Vp> { return ranges::size(_M_base); } constexpr auto size() const requires sized_range { return ranges::size(_M_base); } }; template transform_view(_Range&&, _Fp) -> transform_view, _Fp>; namespace views { inline constexpr __adaptor::_RangeAdaptor transform = [] (_Range&& __r, _Fp&& __f) { return transform_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)}; }; } template class take_view : public view_interface> { private: template using _CI = counted_iterator< iterator_t<__detail::__maybe_const_t<_Const, _Vp>>>; template struct _Sentinel { private: using _Base = __detail::__maybe_const_t<_Const, _Vp>; sentinel_t<_Base> _M_end = sentinel_t<_Base>(); public: _Sentinel() = default; constexpr explicit _Sentinel(sentinel_t<_Base> __end) : _M_end(__end) { } constexpr _Sentinel(_Sentinel __s) requires _Const && convertible_to, sentinel_t<_Base>> : _M_end(std::move(__s._M_end)) { } constexpr sentinel_t<_Base> base() const { return _M_end; } friend constexpr bool operator==(const _CI<_Const>& __y, const _Sentinel& __x) { return __y.count() == 0 || __y.base() == __x._M_end; } template> requires sentinel_for, iterator_t<_Base2>> friend constexpr bool operator==(const _CI<_OtherConst>& __y, const _Sentinel& __x) { return __y.count() == 0 || __y.base() == __x._M_end; } friend _Sentinel; }; _Vp _M_base = _Vp(); range_difference_t<_Vp> _M_count = 0; public: take_view() = default; constexpr take_view(_Vp base, range_difference_t<_Vp> __count) : _M_base(std::move(base)), _M_count(std::move(__count)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr auto begin() requires (!__detail::__simple_view<_Vp>) { if constexpr (sized_range<_Vp>) { if constexpr (random_access_range<_Vp>) return ranges::begin(_M_base); else { auto __sz = size(); return counted_iterator{ranges::begin(_M_base), __sz}; } } else return counted_iterator{ranges::begin(_M_base), _M_count}; } constexpr auto begin() const requires range { if constexpr (sized_range) { if constexpr (random_access_range) return ranges::begin(_M_base); else { auto __sz = size(); return counted_iterator{ranges::begin(_M_base), __sz}; } } else return counted_iterator{ranges::begin(_M_base), _M_count}; } constexpr auto end() requires (!__detail::__simple_view<_Vp>) { if constexpr (sized_range<_Vp>) { if constexpr (random_access_range<_Vp>) return ranges::begin(_M_base) + size(); else return default_sentinel; } else return _Sentinel{ranges::end(_M_base)}; } constexpr auto end() const requires range { if constexpr (sized_range) { if constexpr (random_access_range) return ranges::begin(_M_base) + size(); else return default_sentinel; } else return _Sentinel{ranges::end(_M_base)}; } constexpr auto size() requires sized_range<_Vp> { auto __n = ranges::size(_M_base); return __detail::min(__n, static_cast(_M_count)); } constexpr auto size() const requires sized_range { auto __n = ranges::size(_M_base); return __detail::min(__n, static_cast(_M_count)); } }; template take_view(_Range&&, range_difference_t<_Range>) -> take_view>; template inline constexpr bool enable_borrowed_range> = enable_borrowed_range<_Tp>; namespace views { inline constexpr __adaptor::_RangeAdaptor take = [] (_Range&& __r, _Tp&& __n) { return take_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)}; }; } template requires input_range<_Vp> && is_object_v<_Pred> && indirect_unary_predicate> class take_while_view : public view_interface> { template struct _Sentinel { private: using _Base = __detail::__maybe_const_t<_Const, _Vp>; sentinel_t<_Base> _M_end = sentinel_t<_Base>(); const _Pred* _M_pred = nullptr; public: _Sentinel() = default; constexpr explicit _Sentinel(sentinel_t<_Base> __end, const _Pred* __pred) : _M_end(__end), _M_pred(__pred) { } constexpr _Sentinel(_Sentinel __s) requires _Const && convertible_to, sentinel_t<_Base>> : _M_end(__s._M_end), _M_pred(__s._M_pred) { } constexpr sentinel_t<_Base> base() const { return _M_end; } friend constexpr bool operator==(const iterator_t<_Base>& __x, const _Sentinel& __y) { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); } template> requires sentinel_for, iterator_t<_Base2>> friend constexpr bool operator==(const iterator_t<_Base2>& __x, const _Sentinel& __y) { return __y._M_end == __x || !std::__invoke(*__y._M_pred, *__x); } friend _Sentinel; }; _Vp _M_base = _Vp(); __detail::__box<_Pred> _M_pred; public: take_while_view() = default; constexpr take_while_view(_Vp base, _Pred __pred) : _M_base(std::move(base)), _M_pred(std::move(__pred)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr const _Pred& pred() const { return *_M_pred; } constexpr auto begin() requires (!__detail::__simple_view<_Vp>) { return ranges::begin(_M_base); } constexpr auto begin() const requires range && indirect_unary_predicate> { return ranges::begin(_M_base); } constexpr auto end() requires (!__detail::__simple_view<_Vp>) { return _Sentinel(ranges::end(_M_base), std::__addressof(*_M_pred)); } constexpr auto end() const requires range && indirect_unary_predicate> { return _Sentinel(ranges::end(_M_base), std::__addressof(*_M_pred)); } }; template take_while_view(_Range&&, _Pred) -> take_while_view, _Pred>; namespace views { inline constexpr __adaptor::_RangeAdaptor take_while = [] (_Range&& __r, _Pred&& __p) { return take_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)}; }; } template class drop_view : public view_interface> { private: _Vp _M_base = _Vp(); range_difference_t<_Vp> _M_count = 0; static constexpr bool _S_needs_cached_begin = !(random_access_range && sized_range); [[no_unique_address]] __detail::__maybe_present_t<_S_needs_cached_begin, __detail::_CachedPosition<_Vp>> _M_cached_begin; public: drop_view() = default; constexpr drop_view(_Vp __base, range_difference_t<_Vp> __count) : _M_base(std::move(__base)), _M_count(__count) { ; } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr auto begin() requires (!(__detail::__simple_view<_Vp> && random_access_range && sized_range)) { if constexpr (_S_needs_cached_begin) if (_M_cached_begin._M_has_value()) return _M_cached_begin._M_get(_M_base); auto __it = ranges::next(ranges::begin(_M_base), _M_count, ranges::end(_M_base)); if constexpr (_S_needs_cached_begin) _M_cached_begin._M_set(_M_base, __it); return __it; } constexpr auto begin() const requires random_access_range && sized_range { return ranges::next(ranges::begin(_M_base), _M_count, ranges::end(_M_base)); } constexpr auto end() requires (!__detail::__simple_view<_Vp>) { return ranges::end(_M_base); } constexpr auto end() const requires range { return ranges::end(_M_base); } constexpr auto size() requires sized_range<_Vp> { const auto __s = ranges::size(_M_base); const auto __c = static_cast(_M_count); return __s < __c ? 0 : __s - __c; } constexpr auto size() const requires sized_range { const auto __s = ranges::size(_M_base); const auto __c = static_cast(_M_count); return __s < __c ? 0 : __s - __c; } }; template drop_view(_Range&&, range_difference_t<_Range>) -> drop_view>; template inline constexpr bool enable_borrowed_range> = enable_borrowed_range<_Tp>; namespace views { inline constexpr __adaptor::_RangeAdaptor drop = [] (_Range&& __r, _Tp&& __n) { return drop_view{std::forward<_Range>(__r), std::forward<_Tp>(__n)}; }; } template requires input_range<_Vp> && is_object_v<_Pred> && indirect_unary_predicate> class drop_while_view : public view_interface> { private: _Vp _M_base = _Vp(); __detail::__box<_Pred> _M_pred; [[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin; public: drop_while_view() = default; constexpr drop_while_view(_Vp __base, _Pred __pred) : _M_base(std::move(__base)), _M_pred(std::move(__pred)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr const _Pred& pred() const { return *_M_pred; } constexpr auto begin() { if (_M_cached_begin._M_has_value()) return _M_cached_begin._M_get(_M_base); auto __it = __detail::find_if_not(ranges::begin(_M_base), ranges::end(_M_base), std::cref(*_M_pred)); _M_cached_begin._M_set(_M_base, __it); return __it; } constexpr auto end() { return ranges::end(_M_base); } }; template drop_while_view(_Range&&, _Pred) -> drop_while_view, _Pred>; template inline constexpr bool enable_borrowed_range> = enable_borrowed_range<_Tp>; namespace views { inline constexpr __adaptor::_RangeAdaptor drop_while = [] (_Range&& __r, _Pred&& __p) { return drop_while_view{std::forward<_Range>(__r), std::forward<_Pred>(__p)}; }; } template requires view<_Vp> && input_range> && (is_reference_v> || view>) class join_view : public view_interface> { private: using _InnerRange = range_reference_t<_Vp>; template struct _Sentinel; template struct _Iterator { private: using _Parent = __detail::__maybe_const_t<_Const, join_view>; using _Base = __detail::__maybe_const_t<_Const, _Vp>; static constexpr bool _S_ref_is_glvalue = is_reference_v>; constexpr void _M_satisfy() { auto __update_inner = [this] (range_reference_t<_Base> __x) -> auto& { if constexpr (_S_ref_is_glvalue) return __x; else return (_M_parent->_M_inner = views::all(std::move(__x))); }; for (; _M_outer != ranges::end(_M_parent->_M_base); ++_M_outer) { auto& __inner = __update_inner(*_M_outer); _M_inner = ranges::begin(__inner); if (_M_inner != ranges::end(__inner)) return; } if constexpr (_S_ref_is_glvalue) _M_inner = _Inner_iter(); } static constexpr auto _S_iter_concept() { if constexpr (_S_ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range>) return bidirectional_iterator_tag{}; else if constexpr (_S_ref_is_glvalue && forward_range<_Base> && forward_range>) return forward_iterator_tag{}; else return input_iterator_tag{}; } static constexpr auto _S_iter_cat() { using _OuterCat = typename iterator_traits<_Outer_iter>::iterator_category; using _InnerCat = typename iterator_traits<_Inner_iter>::iterator_category; if constexpr (_S_ref_is_glvalue && derived_from<_OuterCat, bidirectional_iterator_tag> && derived_from<_InnerCat, bidirectional_iterator_tag>) return bidirectional_iterator_tag{}; else if constexpr (_S_ref_is_glvalue && derived_from<_OuterCat, forward_iterator_tag> && derived_from<_InnerCat, forward_iterator_tag>) return forward_iterator_tag{}; else if constexpr (derived_from<_OuterCat, input_iterator_tag> && derived_from<_InnerCat, input_iterator_tag>) return input_iterator_tag{}; else return output_iterator_tag{}; } using _Outer_iter = iterator_t<_Base>; using _Inner_iter = iterator_t>; _Outer_iter _M_outer = _Outer_iter(); _Inner_iter _M_inner = _Inner_iter(); _Parent* _M_parent = nullptr; public: using iterator_concept = decltype(_S_iter_concept()); using iterator_category = decltype(_S_iter_cat()); using value_type = range_value_t>; using difference_type = common_type_t, range_difference_t>>; _Iterator() = default; constexpr _Iterator(_Parent& __parent, _Outer_iter __outer) : _M_outer(std::move(__outer)), _M_parent(std::__addressof(__parent)) { _M_satisfy(); } constexpr _Iterator(_Iterator __i) requires _Const && convertible_to, _Outer_iter> && convertible_to, _Inner_iter> : _M_outer(std::move(__i._M_outer)), _M_inner(__i._M_inner), _M_parent(__i._M_parent) { } constexpr decltype(auto) operator*() const { return *_M_inner; } constexpr _Inner_iter operator->() const requires __detail::__has_arrow<_Inner_iter> && copyable<_Inner_iter> { return _M_inner; } constexpr _Iterator& operator++() { auto&& __inner_range = [this] () -> decltype(auto) { if constexpr (_S_ref_is_glvalue) return *_M_outer; else return _M_parent->_M_inner; }(); if (++_M_inner == ranges::end(__inner_range)) { ++_M_outer; _M_satisfy(); } return *this; } constexpr void operator++(int) { ++*this; } constexpr _Iterator operator++(int) requires _S_ref_is_glvalue && forward_range<_Base> && forward_range> { auto __tmp = *this; ++*this; return __tmp; } constexpr _Iterator& operator--() requires _S_ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range> && common_range> { if (_M_outer == ranges::end(_M_parent->_M_base)) _M_inner = ranges::end(*--_M_outer); while (_M_inner == ranges::begin(*_M_outer)) _M_inner = ranges::end(*--_M_outer); --_M_inner; return *this; } constexpr _Iterator operator--(int) requires _S_ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range> && common_range> { auto __tmp = *this; --*this; return __tmp; } friend constexpr bool operator==(const _Iterator& __x, const _Iterator& __y) requires _S_ref_is_glvalue && equality_comparable<_Outer_iter> && equality_comparable<_Inner_iter> { return (__x._M_outer == __y._M_outer && __x._M_inner == __y._M_inner); } friend constexpr decltype(auto) iter_move(const _Iterator& __i) noexcept(noexcept(ranges::iter_move(__i._M_inner))) { return ranges::iter_move(__i._M_inner); } friend constexpr void iter_swap(const _Iterator& __x, const _Iterator& __y) noexcept(noexcept(ranges::iter_swap(__x._M_inner, __y._M_inner))) { return ranges::iter_swap(__x._M_inner, __y._M_inner); } friend _Iterator; template friend struct _Sentinel; }; template struct _Sentinel { private: using _Parent = __detail::__maybe_const_t<_Const, join_view>; using _Base = __detail::__maybe_const_t<_Const, _Vp>; template constexpr bool __equal(const _Iterator<_Const2>& __i) const { return __i._M_outer == _M_end; } sentinel_t<_Base> _M_end = sentinel_t<_Base>(); public: _Sentinel() = default; constexpr explicit _Sentinel(_Parent& __parent) : _M_end(ranges::end(__parent._M_base)) { } constexpr _Sentinel(_Sentinel __s) requires _Const && convertible_to, sentinel_t<_Base>> : _M_end(std::move(__s._M_end)) { } template requires sentinel_for, iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>> friend constexpr bool operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y) { return __y.__equal(__x); } friend _Sentinel; }; _Vp _M_base = _Vp(); [[no_unique_address]] __detail::__maybe_present_t, views::all_t<_InnerRange>> _M_inner; public: join_view() = default; constexpr explicit join_view(_Vp __base) : _M_base(std::move(__base)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr auto begin() { constexpr bool __use_const = (__detail::__simple_view<_Vp> && is_reference_v>); return _Iterator<__use_const>{*this, ranges::begin(_M_base)}; } constexpr auto begin() const requires input_range && is_reference_v> { return _Iterator{*this, ranges::begin(_M_base)}; } constexpr auto end() { if constexpr (forward_range<_Vp> && is_reference_v<_InnerRange> && forward_range<_InnerRange> && common_range<_Vp> && common_range<_InnerRange>) return _Iterator<__detail::__simple_view<_Vp>>{*this, ranges::end(_M_base)}; else return _Sentinel<__detail::__simple_view<_Vp>>{*this}; } constexpr auto end() const requires input_range && is_reference_v> { if constexpr (forward_range && is_reference_v> && forward_range> && common_range && common_range>) return _Iterator{*this, ranges::end(_M_base)}; else return _Sentinel{*this}; } }; template explicit join_view(_Range&&) -> join_view>; namespace views { inline constexpr __adaptor::_RangeAdaptorClosure join = [] (_Range&& __r) { return join_view>{std::forward<_Range>(__r)}; }; } namespace __detail { template struct __require_constant; template concept __tiny_range = sized_range<_Range> && requires { typename __require_constant::size()>; } && (remove_reference_t<_Range>::size() <= 1); } template requires view<_Vp> && view<_Pattern> && indirectly_comparable, iterator_t<_Pattern>, ranges::equal_to> && (forward_range<_Vp> || __detail::__tiny_range<_Pattern>) class split_view : public view_interface> { private: template struct _InnerIter; template struct _OuterIter { private: using _Parent = __detail::__maybe_const_t<_Const, split_view>; using _Base = __detail::__maybe_const_t<_Const, _Vp>; constexpr bool __at_end() const { return __current() == ranges::end(_M_parent->_M_base); } constexpr auto& __current() noexcept { if constexpr (forward_range<_Vp>) return _M_current; else return _M_parent->_M_current; } constexpr auto& __current() const noexcept { if constexpr (forward_range<_Vp>) return _M_current; else return _M_parent->_M_current; } _Parent* _M_parent = nullptr; [[no_unique_address]] __detail::__maybe_present_t, iterator_t<_Base>> _M_current; public: using iterator_concept = conditional_t, forward_iterator_tag, input_iterator_tag>; using iterator_category = input_iterator_tag; using difference_type = range_difference_t<_Base>; struct value_type : view_interface { private: _OuterIter _M_i = _OuterIter(); public: value_type() = default; constexpr explicit value_type(_OuterIter __i) : _M_i(std::move(__i)) { } constexpr _InnerIter<_Const> begin() const requires copyable<_OuterIter> { return _InnerIter<_Const>{_M_i}; } constexpr _InnerIter<_Const> begin() requires (!copyable<_OuterIter>) { return _InnerIter<_Const>{std::move(_M_i)}; } constexpr default_sentinel_t end() const { return default_sentinel; } }; _OuterIter() = default; constexpr explicit _OuterIter(_Parent& __parent) requires (!forward_range<_Base>) : _M_parent(std::__addressof(__parent)) { } constexpr _OuterIter(_Parent& __parent, iterator_t<_Base> __current) requires forward_range<_Base> : _M_parent(std::__addressof(__parent)), _M_current(std::move(__current)) { } constexpr _OuterIter(_OuterIter __i) requires _Const && convertible_to, iterator_t<_Base>> : _M_parent(__i._M_parent), _M_current(std::move(__i._M_current)) { } constexpr value_type operator*() const { return value_type{*this}; } constexpr _OuterIter& operator++() { const auto __end = ranges::end(_M_parent->_M_base); if (__current() == __end) return *this; const auto [__pbegin, __pend] = subrange{_M_parent->_M_pattern}; if (__pbegin == __pend) ++__current(); else do { auto [__b, __p] = __detail::mismatch(std::move(__current()), __end, __pbegin, __pend); __current() = std::move(__b); if (__p == __pend) break; } while (++__current() != __end); return *this; } constexpr decltype(auto) operator++(int) { if constexpr (forward_range<_Base>) { auto __tmp = *this; ++*this; return __tmp; } else ++*this; } friend constexpr bool operator==(const _OuterIter& __x, const _OuterIter& __y) requires forward_range<_Base> { return __x._M_current == __y._M_current; } friend constexpr bool operator==(const _OuterIter& __x, default_sentinel_t) { return __x.__at_end(); }; friend _OuterIter; friend _InnerIter<_Const>; }; template struct _InnerIter { private: using _Base = __detail::__maybe_const_t<_Const, _Vp>; constexpr bool __at_end() const { auto [__pcur, __pend] = subrange{_M_i._M_parent->_M_pattern}; auto __end = ranges::end(_M_i._M_parent->_M_base); if constexpr (__detail::__tiny_range<_Pattern>) { const auto& __cur = _M_i_current(); if (__cur == __end) return true; if (__pcur == __pend) return _M_incremented; return *__cur == *__pcur; } else { auto __cur = _M_i_current(); if (__cur == __end) return true; if (__pcur == __pend) return _M_incremented; do { if (*__cur != *__pcur) return false; if (++__pcur == __pend) return true; } while (++__cur != __end); return false; } } static constexpr auto _S_iter_cat() { using _Cat = typename iterator_traits>::iterator_category; if constexpr (derived_from<_Cat, forward_iterator_tag>) return forward_iterator_tag{}; else return _Cat{}; } constexpr auto& _M_i_current() noexcept { return _M_i.__current(); } constexpr auto& _M_i_current() const noexcept { return _M_i.__current(); } _OuterIter<_Const> _M_i = _OuterIter<_Const>(); bool _M_incremented = false; public: using iterator_concept = typename _OuterIter<_Const>::iterator_concept; using iterator_category = decltype(_S_iter_cat()); using value_type = range_value_t<_Base>; using difference_type = range_difference_t<_Base>; _InnerIter() = default; constexpr explicit _InnerIter(_OuterIter<_Const> __i) : _M_i(std::move(__i)) { } constexpr decltype(auto) operator*() const { return *_M_i_current(); } constexpr _InnerIter& operator++() { _M_incremented = true; if constexpr (!forward_range<_Base>) if constexpr (_Pattern::size() == 0) return *this; ++_M_i_current(); return *this; } constexpr decltype(auto) operator++(int) { if constexpr (forward_range<_Vp>) { auto __tmp = *this; ++*this; return __tmp; } else ++*this; } friend constexpr bool operator==(const _InnerIter& __x, const _InnerIter& __y) requires forward_range<_Base> { return __x._M_i == __y._M_i; } friend constexpr bool operator==(const _InnerIter& __x, default_sentinel_t) { return __x.__at_end(); } friend constexpr decltype(auto) iter_move(const _InnerIter& __i) noexcept(noexcept(ranges::iter_move(__i._M_i_current()))) { return ranges::iter_move(__i._M_i_current()); } friend constexpr void iter_swap(const _InnerIter& __x, const _InnerIter& __y) noexcept(noexcept(ranges::iter_swap(__x._M_i_current(), __y._M_i_current()))) requires indirectly_swappable> { ranges::iter_swap(__x._M_i_current(), __y._M_i_current()); } }; _Vp _M_base = _Vp(); _Pattern _M_pattern = _Pattern(); [[no_unique_address]] __detail::__maybe_present_t, iterator_t<_Vp>> _M_current; public: split_view() = default; constexpr split_view(_Vp __base, _Pattern __pattern) : _M_base(std::move(__base)), _M_pattern(std::move(__pattern)) { } template requires constructible_from<_Vp, views::all_t<_Range>> && constructible_from<_Pattern, single_view>> constexpr split_view(_Range&& __r, range_value_t<_Range> __e) : _M_base(views::all(std::forward<_Range>(__r))), _M_pattern(std::move(__e)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr auto begin() { if constexpr (forward_range<_Vp>) return _OuterIter<__detail::__simple_view<_Vp>>{ *this, ranges::begin(_M_base)}; else { _M_current = ranges::begin(_M_base); return _OuterIter{*this}; } } constexpr auto begin() const requires forward_range<_Vp> && forward_range { return _OuterIter{*this, ranges::begin(_M_base)}; } constexpr auto end() requires forward_range<_Vp> && common_range<_Vp> { return _OuterIter<__detail::__simple_view<_Vp>>{ *this, ranges::end(_M_base)}; } constexpr auto end() const { if constexpr (forward_range<_Vp> && forward_range && common_range) return _OuterIter{*this, ranges::end(_M_base)}; else return default_sentinel; } }; template split_view(_Range&&, _Pred&&) -> split_view, views::all_t<_Pred>>; template split_view(_Range&&, range_value_t<_Range>) -> split_view, single_view>>; namespace views { inline constexpr __adaptor::_RangeAdaptor split = [] (_Range&& __r, _Fp&& __f) { return split_view{std::forward<_Range>(__r), std::forward<_Fp>(__f)}; }; } namespace views { struct _Counted { template constexpr auto operator()(_Iter __i, iter_difference_t<_Iter> __n) const { if constexpr (random_access_iterator<_Iter>) return subrange{__i, __i + __n}; else return subrange{counted_iterator{std::move(__i), __n}, default_sentinel}; } }; inline constexpr _Counted counted{}; } template requires (!common_range<_Vp>) && copyable> class common_view : public view_interface> { private: _Vp _M_base = _Vp(); public: common_view() = default; constexpr explicit common_view(_Vp __r) : _M_base(std::move(__r)) { } # 3186 "/usr/include/c++/10/ranges" 3 constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr auto begin() { if constexpr (random_access_range<_Vp> && sized_range<_Vp>) return ranges::begin(_M_base); else return common_iterator, sentinel_t<_Vp>> (ranges::begin(_M_base)); } constexpr auto begin() const requires range { if constexpr (random_access_range && sized_range) return ranges::begin(_M_base); else return common_iterator, sentinel_t> (ranges::begin(_M_base)); } constexpr auto end() { if constexpr (random_access_range<_Vp> && sized_range<_Vp>) return ranges::begin(_M_base) + ranges::size(_M_base); else return common_iterator, sentinel_t<_Vp>> (ranges::end(_M_base)); } constexpr auto end() const requires range { if constexpr (random_access_range && sized_range) return ranges::begin(_M_base) + ranges::size(_M_base); else return common_iterator, sentinel_t> (ranges::end(_M_base)); } constexpr auto size() requires sized_range<_Vp> { return ranges::size(_M_base); } constexpr auto size() const requires sized_range { return ranges::size(_M_base); } }; template common_view(_Range&&) -> common_view>; template inline constexpr bool enable_borrowed_range> = enable_borrowed_range<_Tp>; namespace views { inline constexpr __adaptor::_RangeAdaptorClosure common = [] (_Range&& __r) { if constexpr (common_range<_Range> && requires { views::all(std::forward<_Range>(__r)); }) return views::all(std::forward<_Range>(__r)); else return common_view{std::forward<_Range>(__r)}; }; } template requires bidirectional_range<_Vp> class reverse_view : public view_interface> { private: _Vp _M_base = _Vp(); static constexpr bool _S_needs_cached_begin = !common_range<_Vp> && !random_access_range<_Vp>; [[no_unique_address]] __detail::__maybe_present_t<_S_needs_cached_begin, __detail::_CachedPosition<_Vp>> _M_cached_begin; public: reverse_view() = default; constexpr explicit reverse_view(_Vp __r) : _M_base(std::move(__r)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr reverse_iterator> begin() { if constexpr (_S_needs_cached_begin) if (_M_cached_begin._M_has_value()) return std::make_reverse_iterator(_M_cached_begin._M_get(_M_base)); auto __it = ranges::next(ranges::begin(_M_base), ranges::end(_M_base)); if constexpr (_S_needs_cached_begin) _M_cached_begin._M_set(_M_base, __it); return std::make_reverse_iterator(std::move(__it)); } constexpr auto begin() requires common_range<_Vp> { return std::make_reverse_iterator(ranges::end(_M_base)); } constexpr auto begin() const requires common_range { return std::make_reverse_iterator(ranges::end(_M_base)); } constexpr reverse_iterator> end() { return std::make_reverse_iterator(ranges::begin(_M_base)); } constexpr auto end() const requires common_range { return std::make_reverse_iterator(ranges::begin(_M_base)); } constexpr auto size() requires sized_range<_Vp> { return ranges::size(_M_base); } constexpr auto size() const requires sized_range { return ranges::size(_M_base); } }; template reverse_view(_Range&&) -> reverse_view>; template inline constexpr bool enable_borrowed_range> = enable_borrowed_range<_Tp>; namespace views { namespace __detail { template inline constexpr bool __is_reversible_subrange = false; template inline constexpr bool __is_reversible_subrange, reverse_iterator<_Iter>, _Kind>> = true; template inline constexpr bool __is_reverse_view = false; template inline constexpr bool __is_reverse_view> = true; } inline constexpr __adaptor::_RangeAdaptorClosure reverse = [] (_Range&& __r) { using _Tp = remove_cvref_t<_Range>; if constexpr (__detail::__is_reverse_view<_Tp>) return std::forward<_Range>(__r).base(); else if constexpr (__detail::__is_reversible_subrange<_Tp>) { using _Iter = decltype(ranges::begin(__r).base()); if constexpr (sized_range<_Tp>) return subrange<_Iter, _Iter, subrange_kind::sized> (__r.end().base(), __r.begin().base(), __r.size()); else return subrange<_Iter, _Iter, subrange_kind::unsized> (__r.end().base(), __r.begin().base()); } else return reverse_view{std::forward<_Range>(__r)}; }; } namespace __detail { template concept __has_tuple_element = requires(_Tp __t) { typename tuple_size<_Tp>::type; requires _Nm < tuple_size_v<_Tp>; typename tuple_element_t<_Nm, _Tp>; { std::get<_Nm>(__t) } -> convertible_to&>; }; } template requires view<_Vp> && __detail::__has_tuple_element, _Nm> && __detail::__has_tuple_element>, _Nm> class elements_view : public view_interface> { public: elements_view() = default; constexpr explicit elements_view(_Vp base) : _M_base(std::move(base)) { } constexpr _Vp base() const& requires copy_constructible<_Vp> { return _M_base; } constexpr _Vp base() && { return std::move(_M_base); } constexpr auto begin() requires (!__detail::__simple_view<_Vp>) { return _Iterator(ranges::begin(_M_base)); } constexpr auto begin() const requires range { return _Iterator(ranges::begin(_M_base)); } constexpr auto end() requires (!__detail::__simple_view<_Vp> && !common_range<_Vp>) { return _Sentinel{ranges::end(_M_base)}; } constexpr auto end() requires (!__detail::__simple_view<_Vp> && common_range<_Vp>) { return _Iterator{ranges::end(_M_base)}; } constexpr auto end() const requires range { return _Sentinel{ranges::end(_M_base)}; } constexpr auto end() const requires common_range { return _Iterator{ranges::end(_M_base)}; } constexpr auto size() requires sized_range<_Vp> { return ranges::size(_M_base); } constexpr auto size() const requires sized_range { return ranges::size(_M_base); } private: template struct _Sentinel; template struct _Iterator { using _Base = __detail::__maybe_const_t<_Const, _Vp>; iterator_t<_Base> _M_current = iterator_t<_Base>(); friend _Iterator; public: using iterator_category = typename iterator_traits>::iterator_category; using value_type = remove_cvref_t>>; using difference_type = range_difference_t<_Base>; _Iterator() = default; constexpr explicit _Iterator(iterator_t<_Base> current) : _M_current(std::move(current)) { } constexpr _Iterator(_Iterator i) requires _Const && convertible_to, iterator_t<_Base>> : _M_current(std::move(i._M_current)) { } constexpr iterator_t<_Base> base() const& requires copyable> { return _M_current; } constexpr iterator_t<_Base> base() && { return std::move(_M_current); } constexpr decltype(auto) operator*() const { return std::get<_Nm>(*_M_current); } constexpr _Iterator& operator++() { ++_M_current; return *this; } constexpr void operator++(int) requires (!forward_range<_Base>) { ++_M_current; } constexpr _Iterator operator++(int) requires forward_range<_Base> { auto __tmp = *this; ++_M_current; return __tmp; } constexpr _Iterator& operator--() requires bidirectional_range<_Base> { --_M_current; return *this; } constexpr _Iterator operator--(int) requires bidirectional_range<_Base> { auto __tmp = *this; --_M_current; return __tmp; } constexpr _Iterator& operator+=(difference_type __n) requires random_access_range<_Base> { _M_current += __n; return *this; } constexpr _Iterator& operator-=(difference_type __n) requires random_access_range<_Base> { _M_current -= __n; return *this; } constexpr decltype(auto) operator[](difference_type __n) const requires random_access_range<_Base> { return std::get<_Nm>(*(_M_current + __n)); } friend constexpr bool operator==(const _Iterator& __x, const _Iterator& __y) requires equality_comparable> { return __x._M_current == __y._M_current; } friend constexpr bool operator<(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return __x._M_current < __y._M_current; } friend constexpr bool operator>(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return __y._M_current < __x._M_current; } friend constexpr bool operator<=(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return !(__y._M_current > __x._M_current); } friend constexpr bool operator>=(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> { return !(__x._M_current > __y._M_current); } friend constexpr auto operator<=>(const _Iterator& __x, const _Iterator& __y) requires random_access_range<_Base> && three_way_comparable> { return __x._M_current <=> __y._M_current; } friend constexpr _Iterator operator+(const _Iterator& __x, difference_type __y) requires random_access_range<_Base> { return _Iterator{__x} += __y; } friend constexpr _Iterator operator+(difference_type __x, const _Iterator& __y) requires random_access_range<_Base> { return __y + __x; } friend constexpr _Iterator operator-(const _Iterator& __x, difference_type __y) requires random_access_range<_Base> { return _Iterator{__x} -= __y; } friend constexpr difference_type operator-(const _Iterator& __x, const _Iterator& __y) requires sized_sentinel_for, iterator_t<_Base>> { return __x._M_current - __y._M_current; } friend _Sentinel<_Const>; }; template struct _Sentinel { private: constexpr bool _M_equal(const _Iterator<_Const>& __x) const { return __x._M_current == _M_end; } using _Base = __detail::__maybe_const_t<_Const, _Vp>; sentinel_t<_Base> _M_end = sentinel_t<_Base>(); public: _Sentinel() = default; constexpr explicit _Sentinel(sentinel_t<_Base> __end) : _M_end(std::move(__end)) { } constexpr _Sentinel(_Sentinel __other) requires _Const && convertible_to, sentinel_t<_Base>> : _M_end(std::move(__other._M_end)) { } constexpr sentinel_t<_Base> base() const { return _M_end; } template requires sentinel_for, iterator_t<__detail::__maybe_const_t<_Const2, _Vp>>> friend constexpr bool operator==(const _Iterator<_Const2>& __x, const _Sentinel& __y) { return __y._M_equal(__x); } template> requires sized_sentinel_for, iterator_t<_Base2>> friend constexpr range_difference_t<_Base2> operator-(const _Iterator<_Const2>& __x, const _Sentinel& __y) { return __x._M_current - __y._M_end; } template> requires sized_sentinel_for, iterator_t<_Base2>> friend constexpr range_difference_t<_Base> operator-(const _Sentinel& __x, const _Iterator<_Const2>& __y) { return __x._M_end - __y._M_current; } friend _Sentinel; }; _Vp _M_base = _Vp(); }; template inline constexpr bool enable_borrowed_range> = enable_borrowed_range<_Tp>; template using keys_view = elements_view, 0>; template using values_view = elements_view, 1>; namespace views { template inline constexpr __adaptor::_RangeAdaptorClosure elements = [] (_Range&& __r) { using _El = elements_view, _Nm>; return _El{std::forward<_Range>(__r)}; }; inline constexpr __adaptor::_RangeAdaptorClosure keys = elements<0>; inline constexpr __adaptor::_RangeAdaptorClosure values = elements<1>; } } namespace views = ranges::views; template struct tuple_size> : integral_constant { }; template struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>> { using type = _Iter; }; template struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>> { using type = _Sent; }; template struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>> { using type = _Iter; }; template struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>> { using type = _Sent; }; } # 39 "/usr/include/c++/10/bits/ranges_algobase.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace ranges { namespace __detail { template constexpr inline bool __is_normal_iterator = false; template constexpr inline bool __is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator, _Container>> = true; template constexpr inline bool __is_reverse_iterator = false; template constexpr inline bool __is_reverse_iterator> = true; template constexpr inline bool __is_move_iterator = false; template constexpr inline bool __is_move_iterator> = true; } struct __equal_fn { template _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 requires indirectly_comparable, 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 struct in_out_result { [[no_unique_address]] _Iter in; [[no_unique_address]] _Out out; template requires convertible_to && convertible_to constexpr operator in_out_result<_Iter2, _Out2>() const & { return {in, out}; } template requires convertible_to<_Iter, _Iter2> && convertible_to<_Out, _Out2> constexpr operator in_out_result<_Iter2, _Out2>() && { return {std::move(in), std::move(out)}; } }; template using copy_result = in_out_result<_Iter, _Out>; template using move_result = in_out_result<_Iter, _Out>; template using move_backward_result = in_out_result<_Iter1, _Iter2>; template using copy_backward_result = in_out_result<_Iter1, _Iter2>; template _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 _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(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(), __result); return {decltype(__first){__in}, std::move(__out)}; } else if constexpr (__is_normal_iterator<_Out>) { auto [__in,__out] = ranges::__copy_or_move<_IsMove>(__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 _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(std::move(__first), std::move(__last), std::move(__result)); } template requires indirectly_copyable, _Out> constexpr copy_result, _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 _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(std::move(__first), std::move(__last), std::move(__result)); } template requires indirectly_movable, _Out> constexpr move_result, _Out> operator()(_Range&& __r, _Out __result) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result)); } }; inline constexpr __move_fn move{}; template _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) { 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 _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(std::move(__first), std::move(__last), std::move(__result)); } template requires indirectly_copyable, _Iter> constexpr copy_backward_result, _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 _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(std::move(__first), std::move(__last), std::move(__result)); } template requires indirectly_movable, _Iter> constexpr move_backward_result, _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 using copy_n_result = in_out_result<_Iter, _Out>; struct __copy_n_fn { template 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 _Out> constexpr _Out operator()(_Out __first, iter_difference_t<_Out> __n, const _Tp& __value) const { if (__n <= 0) return __first; if constexpr (is_pointer_v<_Out> && __is_byte>::__value && integral<_Tp>) { __builtin_memset(__first, static_cast(__value), __n); return __first + __n; } else if constexpr (is_scalar_v<_Tp>) { 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 _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 _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{}; } } # 37 "/usr/include/c++/10/bits/ranges_uninitialized.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace ranges { namespace __detail { template constexpr void* __voidify(_Tp& __obj) noexcept { return const_cast (static_cast(std::__addressof(__obj))); } template concept __nothrow_input_iterator = (input_iterator<_Iter> && is_lvalue_reference_v> && same_as>, iter_value_t<_Iter>>); template concept __nothrow_sentinel = sentinel_for<_Sent, _Iter>; template concept __nothrow_input_range = (range<_Range> && __nothrow_input_iterator> && __nothrow_sentinel, iterator_t<_Range>>); template concept __nothrow_forward_iterator = (__nothrow_input_iterator<_Iter> && forward_iterator<_Iter> && __nothrow_sentinel<_Iter, _Iter>); template concept __nothrow_forward_range = (__nothrow_input_range<_Range> && __nothrow_forward_iterator>); } struct __destroy_fn { template<__detail::__nothrow_input_iterator _Iter, __detail::__nothrow_sentinel<_Iter> _Sent> requires destructible> constexpr _Iter operator()(_Iter __first, _Sent __last) const noexcept; template<__detail::__nothrow_input_range _Range> requires destructible> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r) const noexcept; }; inline constexpr __destroy_fn destroy{}; namespace __detail { template requires destructible> struct _DestroyGuard { private: _Iter _M_first; const _Iter* _M_cur; public: explicit _DestroyGuard(const _Iter* __iter) : _M_first(*__iter), _M_cur(__iter) { } void release() noexcept { _M_cur = nullptr; } ~_DestroyGuard() { if (_M_cur != nullptr) ranges::destroy(std::move(_M_first), *_M_cur); } }; template requires destructible> && is_trivially_destructible_v> struct _DestroyGuard<_Iter> { explicit _DestroyGuard(const _Iter*) { } void release() noexcept { } }; } struct __uninitialized_default_construct_fn { template<__detail::__nothrow_forward_iterator _Iter, __detail::__nothrow_sentinel<_Iter> _Sent> requires default_initializable> _Iter operator()(_Iter __first, _Sent __last) const { using _ValueType = remove_reference_t>; if constexpr (is_trivially_default_constructible_v<_ValueType>) return ranges::next(__first, __last); else { auto __guard = __detail::_DestroyGuard(&__first); for (; __first != __last; ++__first) ::new (__detail::__voidify(*__first)) _ValueType; __guard.release(); return __first; } } template<__detail::__nothrow_forward_range _Range> requires default_initializable> borrowed_iterator_t<_Range> operator()(_Range&& __r) const { return (*this)(ranges::begin(__r), ranges::end(__r)); } }; inline constexpr __uninitialized_default_construct_fn uninitialized_default_construct{}; struct __uninitialized_default_construct_n_fn { template<__detail::__nothrow_forward_iterator _Iter> requires default_initializable> _Iter operator()(_Iter __first, iter_difference_t<_Iter> __n) const { using _ValueType = remove_reference_t>; if constexpr (is_trivially_default_constructible_v<_ValueType>) return ranges::next(__first, __n); else { auto __guard = __detail::_DestroyGuard(&__first); for (; __n > 0; ++__first, (void) --__n) ::new (__detail::__voidify(*__first)) _ValueType; __guard.release(); return __first; } } }; inline constexpr __uninitialized_default_construct_n_fn uninitialized_default_construct_n; struct __uninitialized_value_construct_fn { template<__detail::__nothrow_forward_iterator _Iter, __detail::__nothrow_sentinel<_Iter> _Sent> requires default_initializable> _Iter operator()(_Iter __first, _Sent __last) const { using _ValueType = remove_reference_t>; if constexpr (is_trivial_v<_ValueType> && is_copy_assignable_v<_ValueType>) return ranges::fill(__first, __last, _ValueType()); else { auto __guard = __detail::_DestroyGuard(&__first); for (; __first != __last; ++__first) ::new (__detail::__voidify(*__first)) _ValueType(); __guard.release(); return __first; } } template<__detail::__nothrow_forward_range _Range> requires default_initializable> borrowed_iterator_t<_Range> operator()(_Range&& __r) const { return (*this)(ranges::begin(__r), ranges::end(__r)); } }; inline constexpr __uninitialized_value_construct_fn uninitialized_value_construct{}; struct __uninitialized_value_construct_n_fn { template<__detail::__nothrow_forward_iterator _Iter> requires default_initializable> _Iter operator()(_Iter __first, iter_difference_t<_Iter> __n) const { using _ValueType = remove_reference_t>; if constexpr (is_trivial_v<_ValueType> && is_copy_assignable_v<_ValueType>) return ranges::fill_n(__first, __n, _ValueType()); else { auto __guard = __detail::_DestroyGuard(&__first); for (; __n > 0; ++__first, (void) --__n) ::new (__detail::__voidify(*__first)) _ValueType(); __guard.release(); return __first; } } }; inline constexpr __uninitialized_value_construct_n_fn uninitialized_value_construct_n; template using uninitialized_copy_result = in_out_result<_Iter, _Out>; struct __uninitialized_copy_fn { template _ISent, __detail::__nothrow_forward_iterator _Out, __detail::__nothrow_sentinel<_Out> _OSent> requires constructible_from, iter_reference_t<_Iter>> uninitialized_copy_result<_Iter, _Out> operator()(_Iter __ifirst, _ISent __ilast, _Out __ofirst, _OSent __olast) const { using _OutType = remove_reference_t>; if constexpr (sized_sentinel_for<_ISent, _Iter> && sized_sentinel_for<_OSent, _Out> && is_trivial_v<_OutType> && is_nothrow_assignable_v<_OutType&, iter_reference_t<_Iter>>) { auto __d1 = __ilast - __ifirst; auto __d2 = __olast - __ofirst; return ranges::copy_n(std::move(__ifirst), std::min(__d1, __d2), __ofirst); } else { auto __guard = __detail::_DestroyGuard(&__ofirst); for (; __ifirst != __ilast && __ofirst != __olast; ++__ofirst, (void)++__ifirst) ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst); __guard.release(); return {std::move(__ifirst), __ofirst}; } } template requires constructible_from, range_reference_t<_IRange>> uninitialized_copy_result, borrowed_iterator_t<_ORange>> operator()(_IRange&& __inr, _ORange&& __outr) const { return (*this)(ranges::begin(__inr), ranges::end(__inr), ranges::begin(__outr), ranges::end(__outr)); } }; inline constexpr __uninitialized_copy_fn uninitialized_copy{}; template using uninitialized_copy_n_result = in_out_result<_Iter, _Out>; struct __uninitialized_copy_n_fn { template _Sent> requires constructible_from, iter_reference_t<_Iter>> uninitialized_copy_n_result<_Iter, _Out> operator()(_Iter __ifirst, iter_difference_t<_Iter> __n, _Out __ofirst, _Sent __olast) const { using _OutType = remove_reference_t>; if constexpr (sized_sentinel_for<_Sent, _Out> && is_trivial_v<_OutType> && is_nothrow_assignable_v<_OutType&, iter_reference_t<_Iter>>) { auto __d = __olast - __ofirst; return ranges::copy_n(std::move(__ifirst), std::min(__n, __d), __ofirst); } else { auto __guard = __detail::_DestroyGuard(&__ofirst); for (; __n > 0 && __ofirst != __olast; ++__ofirst, (void)++__ifirst, (void)--__n) ::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst); __guard.release(); return {std::move(__ifirst), __ofirst}; } } }; inline constexpr __uninitialized_copy_n_fn uninitialized_copy_n{}; template using uninitialized_move_result = in_out_result<_Iter, _Out>; struct __uninitialized_move_fn { template _ISent, __detail::__nothrow_forward_iterator _Out, __detail::__nothrow_sentinel<_Out> _OSent> requires constructible_from, iter_rvalue_reference_t<_Iter>> uninitialized_move_result<_Iter, _Out> operator()(_Iter __ifirst, _ISent __ilast, _Out __ofirst, _OSent __olast) const { using _OutType = remove_reference_t>; if constexpr (sized_sentinel_for<_ISent, _Iter> && sized_sentinel_for<_OSent, _Out> && is_trivial_v<_OutType> && is_nothrow_assignable_v<_OutType&, iter_rvalue_reference_t<_Iter>>) { auto __d1 = __ilast - __ifirst; auto __d2 = __olast - __ofirst; auto [__in, __out] = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)), std::min(__d1, __d2), __ofirst); return {std::move(__in).base(), __out}; } else { auto __guard = __detail::_DestroyGuard(&__ofirst); for (; __ifirst != __ilast && __ofirst != __olast; ++__ofirst, (void)++__ifirst) ::new (__detail::__voidify(*__ofirst)) _OutType(ranges::iter_move(__ifirst)); __guard.release(); return {std::move(__ifirst), __ofirst}; } } template requires constructible_from, range_rvalue_reference_t<_IRange>> uninitialized_move_result, borrowed_iterator_t<_ORange>> operator()(_IRange&& __inr, _ORange&& __outr) const { return (*this)(ranges::begin(__inr), ranges::end(__inr), ranges::begin(__outr), ranges::end(__outr)); } }; inline constexpr __uninitialized_move_fn uninitialized_move{}; template using uninitialized_move_n_result = in_out_result<_Iter, _Out>; struct __uninitialized_move_n_fn { template _Sent> requires constructible_from, iter_rvalue_reference_t<_Iter>> uninitialized_move_n_result<_Iter, _Out> operator()(_Iter __ifirst, iter_difference_t<_Iter> __n, _Out __ofirst, _Sent __olast) const { using _OutType = remove_reference_t>; if constexpr (sized_sentinel_for<_Sent, _Out> && is_trivial_v<_OutType> && is_nothrow_assignable_v<_OutType&, iter_rvalue_reference_t<_Iter>>) { auto __d = __olast - __ofirst; auto [__in, __out] = ranges::copy_n(std::make_move_iterator(std::move(__ifirst)), std::min(__n, __d), __ofirst); return {std::move(__in).base(), __out}; } else { auto __guard = __detail::_DestroyGuard(&__ofirst); for (; __n > 0 && __ofirst != __olast; ++__ofirst, (void)++__ifirst, (void)--__n) ::new (__detail::__voidify(*__ofirst)) _OutType(ranges::iter_move(__ifirst)); __guard.release(); return {std::move(__ifirst), __ofirst}; } } }; inline constexpr __uninitialized_move_n_fn uninitialized_move_n{}; struct __uninitialized_fill_fn { template<__detail::__nothrow_forward_iterator _Iter, __detail::__nothrow_sentinel<_Iter> _Sent, typename _Tp> requires constructible_from, const _Tp&> _Iter operator()(_Iter __first, _Sent __last, const _Tp& __x) const { using _ValueType = remove_reference_t>; if constexpr (is_trivial_v<_ValueType> && is_nothrow_assignable_v<_ValueType&, const _Tp&>) return ranges::fill(__first, __last, __x); else { auto __guard = __detail::_DestroyGuard(&__first); for (; __first != __last; ++__first) ::new (__detail::__voidify(*__first)) _ValueType(__x); __guard.release(); return __first; } } template<__detail::__nothrow_forward_range _Range, typename _Tp> requires constructible_from, const _Tp&> borrowed_iterator_t<_Range> operator()(_Range&& __r, const _Tp& __x) const { return (*this)(ranges::begin(__r), ranges::end(__r), __x); } }; inline constexpr __uninitialized_fill_fn uninitialized_fill{}; struct __uninitialized_fill_n_fn { template<__detail::__nothrow_forward_iterator _Iter, typename _Tp> requires constructible_from, const _Tp&> _Iter operator()(_Iter __first, iter_difference_t<_Iter> __n, const _Tp& __x) const { using _ValueType = remove_reference_t>; if constexpr (is_trivial_v<_ValueType> && is_nothrow_assignable_v<_ValueType&, const _Tp&>) return ranges::fill_n(__first, __n, __x); else { auto __guard = __detail::_DestroyGuard(&__first); for (; __n > 0; ++__first, (void)--__n) ::new (__detail::__voidify(*__first)) _ValueType(__x); __guard.release(); return __first; } } }; inline constexpr __uninitialized_fill_n_fn uninitialized_fill_n{}; struct __construct_at_fn { template requires requires { ::new (std::declval()) _Tp(std::declval<_Args>()...); } constexpr _Tp* operator()(_Tp* __location, _Args&&... __args) const noexcept(noexcept(std::construct_at(__location, std::forward<_Args>(__args)...))) { return std::construct_at(__location, std::forward<_Args>(__args)...); } }; inline constexpr __construct_at_fn construct_at{}; struct __destroy_at_fn { template constexpr void operator()(_Tp* __location) const noexcept { if constexpr (is_array_v<_Tp>) ranges::destroy(ranges::begin(*__location), ranges::end(*__location)); else __location->~_Tp(); } }; inline constexpr __destroy_at_fn destroy_at{}; template<__detail::__nothrow_input_iterator _Iter, __detail::__nothrow_sentinel<_Iter> _Sent> requires destructible> constexpr _Iter __destroy_fn::operator()(_Iter __first, _Sent __last) const noexcept { if constexpr (is_trivially_destructible_v>) return ranges::next(std::move(__first), __last); else { for (; __first != __last; ++__first) ranges::destroy_at(std::__addressof(*__first)); return __first; } } template<__detail::__nothrow_input_range _Range> requires destructible> constexpr borrowed_iterator_t<_Range> __destroy_fn::operator()(_Range&& __r) const noexcept { return (*this)(ranges::begin(__r), ranges::end(__r)); } struct __destroy_n_fn { template<__detail::__nothrow_input_iterator _Iter> requires destructible> constexpr _Iter operator()(_Iter __first, iter_difference_t<_Iter> __n) const noexcept { if constexpr (is_trivially_destructible_v>) return ranges::next(std::move(__first), __n); else { for (; __n > 0; ++__first, (void)--__n) ranges::destroy_at(std::__addressof(*__first)); return __first; } } }; inline constexpr __destroy_n_fn destroy_n{}; } } # 70 "/usr/include/c++/10/memory" 2 3 # 1 "/usr/include/c++/10/ext/concurrence.h" 1 3 # 32 "/usr/include/c++/10/ext/concurrence.h" 3 # 33 "/usr/include/c++/10/ext/concurrence.h" 3 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; static const _Lock_policy __default_lock_policy = _S_atomic; class __concurrence_lock_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_lock_error"; } }; class __concurrence_unlock_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_unlock_error"; } }; class __concurrence_broadcast_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_broadcast_error"; } }; class __concurrence_wait_error : public std::exception { public: virtual char const* what() const throw() { return "__gnu_cxx::__concurrence_wait_error"; } }; inline void __throw_concurrence_lock_error() { (throw (__concurrence_lock_error())); } inline void __throw_concurrence_unlock_error() { (throw (__concurrence_unlock_error())); } inline void __throw_concurrence_broadcast_error() { (throw (__concurrence_broadcast_error())); } inline void __throw_concurrence_wait_error() { (throw (__concurrence_wait_error())); } class __mutex { private: __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } }; __mutex(const __mutex&); __mutex& operator=(const __mutex&); public: __mutex() { } # 144 "/usr/include/c++/10/ext/concurrence.h" 3 void lock() { if (__gthread_active_p()) { if (__gthread_mutex_lock(&_M_mutex) != 0) __throw_concurrence_lock_error(); } } void unlock() { if (__gthread_active_p()) { if (__gthread_mutex_unlock(&_M_mutex) != 0) __throw_concurrence_unlock_error(); } } __gthread_mutex_t* gthread_mutex(void) { return &_M_mutex; } }; class __recursive_mutex { private: __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } }; __recursive_mutex(const __recursive_mutex&); __recursive_mutex& operator=(const __recursive_mutex&); public: __recursive_mutex() { } # 199 "/usr/include/c++/10/ext/concurrence.h" 3 void lock() { if (__gthread_active_p()) { if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) __throw_concurrence_lock_error(); } } void unlock() { if (__gthread_active_p()) { if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) __throw_concurrence_unlock_error(); } } __gthread_recursive_mutex_t* gthread_recursive_mutex(void) { return &_M_mutex; } }; class __scoped_lock { public: typedef __mutex __mutex_type; private: __mutex_type& _M_device; __scoped_lock(const __scoped_lock&); __scoped_lock& operator=(const __scoped_lock&); public: explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) { _M_device.lock(); } ~__scoped_lock() throw() { _M_device.unlock(); } }; class __cond { private: __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }; __cond(const __cond&); __cond& operator=(const __cond&); public: __cond() { } # 277 "/usr/include/c++/10/ext/concurrence.h" 3 void broadcast() { if (__gthread_active_p()) { if (__gthread_cond_broadcast(&_M_cond) != 0) __throw_concurrence_broadcast_error(); } } void wait(__mutex *mutex) { { if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) __throw_concurrence_wait_error(); } } void wait_recursive(__recursive_mutex *mutex) { { if (__gthread_cond_wait_recursive(&_M_cond, mutex->gthread_recursive_mutex()) != 0) __throw_concurrence_wait_error(); } } }; } # 77 "/usr/include/c++/10/memory" 2 3 # 1 "/usr/include/c++/10/bits/unique_ptr.h" 1 3 # 42 "/usr/include/c++/10/bits/unique_ptr.h" 3 # 1 "/usr/include/c++/10/ostream" 1 3 # 36 "/usr/include/c++/10/ostream" 3 # 37 "/usr/include/c++/10/ostream" 3 # 1 "/usr/include/c++/10/ios" 1 3 # 36 "/usr/include/c++/10/ios" 3 # 37 "/usr/include/c++/10/ios" 3 # 1 "/usr/include/c++/10/bits/basic_ios.h" 1 3 # 33 "/usr/include/c++/10/bits/basic_ios.h" 3 # 34 "/usr/include/c++/10/bits/basic_ios.h" 3 # 1 "/usr/include/c++/10/bits/locale_facets.h" 1 3 # 37 "/usr/include/c++/10/bits/locale_facets.h" 3 # 38 "/usr/include/c++/10/bits/locale_facets.h" 3 # 1 "/usr/include/c++/10/cwctype" 1 3 # 39 "/usr/include/c++/10/cwctype" 3 # 40 "/usr/include/c++/10/cwctype" 3 # 50 "/usr/include/c++/10/cwctype" 3 # 1 "/usr/include/wctype.h" 1 3 4 # 38 "/usr/include/wctype.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 1 3 4 # 38 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 3 4 typedef unsigned long int wctype_t; # 56 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 3 4 enum { __ISwupper = 0, __ISwlower = 1, __ISwalpha = 2, __ISwdigit = 3, __ISwxdigit = 4, __ISwspace = 5, __ISwprint = 6, __ISwgraph = 7, __ISwblank = 8, __ISwcntrl = 9, __ISwpunct = 10, __ISwalnum = 11, _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))), _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))), _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))), _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))), _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))), _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))), _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))), _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))), _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))), _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))), _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))), _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24)))) }; extern "C" { extern int iswalnum (wint_t __wc) throw (); extern int iswalpha (wint_t __wc) throw (); extern int iswcntrl (wint_t __wc) throw (); extern int iswdigit (wint_t __wc) throw (); extern int iswgraph (wint_t __wc) throw (); extern int iswlower (wint_t __wc) throw (); extern int iswprint (wint_t __wc) throw (); extern int iswpunct (wint_t __wc) throw (); extern int iswspace (wint_t __wc) throw (); extern int iswupper (wint_t __wc) throw (); extern int iswxdigit (wint_t __wc) throw (); extern int iswblank (wint_t __wc) throw (); # 155 "/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h" 3 4 extern wctype_t wctype (const char *__property) throw (); extern int iswctype (wint_t __wc, wctype_t __desc) throw (); extern wint_t towlower (wint_t __wc) throw (); extern wint_t towupper (wint_t __wc) throw (); } # 39 "/usr/include/wctype.h" 2 3 4 extern "C" { typedef const __int32_t *wctrans_t; extern wctrans_t wctrans (const char *__property) throw (); extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw (); extern int iswalnum_l (wint_t __wc, locale_t __locale) throw (); extern int iswalpha_l (wint_t __wc, locale_t __locale) throw (); extern int iswcntrl_l (wint_t __wc, locale_t __locale) throw (); extern int iswdigit_l (wint_t __wc, locale_t __locale) throw (); extern int iswgraph_l (wint_t __wc, locale_t __locale) throw (); extern int iswlower_l (wint_t __wc, locale_t __locale) throw (); extern int iswprint_l (wint_t __wc, locale_t __locale) throw (); extern int iswpunct_l (wint_t __wc, locale_t __locale) throw (); extern int iswspace_l (wint_t __wc, locale_t __locale) throw (); extern int iswupper_l (wint_t __wc, locale_t __locale) throw (); extern int iswxdigit_l (wint_t __wc, locale_t __locale) throw (); extern int iswblank_l (wint_t __wc, locale_t __locale) throw (); extern wctype_t wctype_l (const char *__property, locale_t __locale) throw (); extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale) throw (); extern wint_t towlower_l (wint_t __wc, locale_t __locale) throw (); extern wint_t towupper_l (wint_t __wc, locale_t __locale) throw (); extern wctrans_t wctrans_l (const char *__property, locale_t __locale) throw (); extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, locale_t __locale) throw (); } # 51 "/usr/include/c++/10/cwctype" 2 3 # 80 "/usr/include/c++/10/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 "/usr/include/c++/10/bits/locale_facets.h" 2 3 # 1 "/usr/include/c++/10/cctype" 1 3 # 39 "/usr/include/c++/10/cctype" 3 # 40 "/usr/include/c++/10/cctype" 3 # 41 "/usr/include/c++/10/bits/locale_facets.h" 2 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/ctype_base.h" 1 3 # 36 "/usr/include/x86_64-linux-gnu/c++/10/bits/ctype_base.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct ctype_base { typedef const int* __to_type; typedef unsigned short mask; static const mask upper = _ISupper; static const mask lower = _ISlower; static const mask alpha = _ISalpha; static const mask digit = _ISdigit; static const mask xdigit = _ISxdigit; static const mask space = _ISspace; static const mask print = _ISprint; static const mask graph = _ISalpha | _ISdigit | _ISpunct; static const mask cntrl = _IScntrl; static const mask punct = _ISpunct; static const mask alnum = _ISalpha | _ISdigit; static const mask blank = _ISblank; }; } # 42 "/usr/include/c++/10/bits/locale_facets.h" 2 3 # 50 "/usr/include/c++/10/bits/locale_facets.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 71 "/usr/include/c++/10/bits/locale_facets.h" 3 template 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 struct __pad { static void _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds, streamsize __newlen, streamsize __oldlen); }; template _CharT* __add_grouping(_CharT* __s, _CharT __sep, const char* __gbeg, size_t __gsize, const _CharT* __first, const _CharT* __last); template inline ostreambuf_iterator<_CharT> __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) { __s._M_put(__ws, __len); return __s; } template inline _OutIter __write(_OutIter __s, const _CharT* __ws, int __len) { for (int __j = 0; __j < __len; __j++, ++__s) *__s = __ws[__j]; return __s; } # 149 "/usr/include/c++/10/bits/locale_facets.h" 3 template class __ctype_abstract_base : public locale::facet, public ctype_base { public: typedef _CharT char_type; # 168 "/usr/include/c++/10/bits/locale_facets.h" 3 bool is(mask __m, char_type __c) const { return this->do_is(__m, __c); } # 185 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* is(const char_type *__lo, const char_type *__hi, mask *__vec) const { return this->do_is(__lo, __hi, __vec); } # 201 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* scan_is(mask __m, const char_type* __lo, const char_type* __hi) const { return this->do_scan_is(__m, __lo, __hi); } # 217 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* scan_not(mask __m, const char_type* __lo, const char_type* __hi) const { return this->do_scan_not(__m, __lo, __hi); } # 231 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type toupper(char_type __c) const { return this->do_toupper(__c); } # 246 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* toupper(char_type *__lo, const char_type* __hi) const { return this->do_toupper(__lo, __hi); } # 260 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type tolower(char_type __c) const { return this->do_tolower(__c); } # 275 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* tolower(char_type* __lo, const char_type* __hi) const { return this->do_tolower(__lo, __hi); } # 292 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type widen(char __c) const { return this->do_widen(__c); } # 311 "/usr/include/c++/10/bits/locale_facets.h" 3 const char* widen(const char* __lo, const char* __hi, char_type* __to) const { return this->do_widen(__lo, __hi, __to); } # 330 "/usr/include/c++/10/bits/locale_facets.h" 3 char narrow(char_type __c, char __dfault) const { return this->do_narrow(__c, __dfault); } # 352 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const { return this->do_narrow(__lo, __hi, __dfault, __to); } protected: explicit __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } virtual ~__ctype_abstract_base() { } # 377 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual bool do_is(mask __m, char_type __c) const = 0; # 396 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const = 0; # 415 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const = 0; # 434 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const = 0; # 452 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_toupper(char_type __c) const = 0; # 469 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const = 0; # 485 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_tolower(char_type __c) const = 0; # 502 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const = 0; # 521 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_widen(char __c) const = 0; # 542 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; # 563 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char do_narrow(char_type __c, char __dfault) const = 0; # 588 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const = 0; }; # 611 "/usr/include/c++/10/bits/locale_facets.h" 3 template class ctype : public __ctype_abstract_base<_CharT> { public: typedef _CharT char_type; typedef typename __ctype_abstract_base<_CharT>::mask mask; static locale::id id; explicit ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } protected: virtual ~ctype(); virtual bool do_is(mask __m, char_type __c) const; virtual const char_type* do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; virtual const char_type* do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; virtual const char_type* do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const; virtual char_type do_toupper(char_type __c) const; virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const; virtual char_type do_tolower(char_type __c) const; virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const; virtual char_type do_widen(char __c) const; virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __dest) const; virtual char do_narrow(char_type, char __dfault) const; virtual const char_type* do_narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const; }; template locale::id ctype<_CharT>::id; # 680 "/usr/include/c++/10/bits/locale_facets.h" 3 template<> class ctype : 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(-1)]; mutable char _M_narrow[1 + static_cast(-1)]; mutable char _M_narrow_ok; public: static locale::id id; static const size_t table_size = 1 + static_cast(-1); # 717 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); # 730 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, size_t __refs = 0); # 743 "/usr/include/c++/10/bits/locale_facets.h" 3 inline bool is(mask __m, char __c) const; # 758 "/usr/include/c++/10/bits/locale_facets.h" 3 inline const char* is(const char* __lo, const char* __hi, mask* __vec) const; # 772 "/usr/include/c++/10/bits/locale_facets.h" 3 inline const char* scan_is(mask __m, const char* __lo, const char* __hi) const; # 786 "/usr/include/c++/10/bits/locale_facets.h" 3 inline const char* scan_not(mask __m, const char* __lo, const char* __hi) const; # 801 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type toupper(char_type __c) const { return this->do_toupper(__c); } # 818 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* toupper(char_type *__lo, const char_type* __hi) const { return this->do_toupper(__lo, __hi); } # 834 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type tolower(char_type __c) const { return this->do_tolower(__c); } # 851 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* tolower(char_type* __lo, const char_type* __hi) const { return this->do_tolower(__lo, __hi); } # 871 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type widen(char __c) const { if (_M_widen_ok) return _M_widen[static_cast(__c)]; this->_M_widen_init(); return this->do_widen(__c); } # 898 "/usr/include/c++/10/bits/locale_facets.h" 3 const char* widen(const char* __lo, const char* __hi, char_type* __to) const { if (_M_widen_ok == 1) { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } if (!_M_widen_ok) _M_widen_init(); return this->do_widen(__lo, __hi, __to); } # 930 "/usr/include/c++/10/bits/locale_facets.h" 3 char narrow(char_type __c, char __dfault) const { if (_M_narrow[static_cast(__c)]) return _M_narrow[static_cast(__c)]; const char __t = do_narrow(__c, __dfault); if (__t != __dfault) _M_narrow[static_cast(__c)] = __t; return __t; } # 963 "/usr/include/c++/10/bits/locale_facets.h" 3 const char_type* narrow(const char_type* __lo, const char_type* __hi, char __dfault, char* __to) const { if (__builtin_expect(_M_narrow_ok == 1, true)) { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } if (!_M_narrow_ok) _M_narrow_init(); return this->do_narrow(__lo, __hi, __dfault, __to); } const mask* table() const throw() { return _M_table; } static const mask* classic_table() throw(); protected: virtual ~ctype(); # 1013 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_toupper(char_type __c) const; # 1030 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const; # 1046 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_tolower(char_type __c) const; # 1063 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const; # 1083 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_widen(char __c) const { return __c; } # 1106 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __to) const { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } # 1133 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const { return __c; } # 1159 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_narrow(const char_type* __lo, const char_type* __hi, char __dfault __attribute__((__unused__)), char* __to) const { if (__builtin_expect(__hi != __lo, true)) __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } private: void _M_narrow_init() const; void _M_widen_init() const; }; # 1185 "/usr/include/c++/10/bits/locale_facets.h" 3 template<> class ctype : public __ctype_abstract_base { 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(-1)]; mask _M_bit[16]; __wmask_type _M_wmask[16]; public: static locale::id id; # 1218 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit ctype(size_t __refs = 0); # 1229 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit ctype(__c_locale __cloc, size_t __refs = 0); protected: __wmask_type _M_convert_to_wmask(const mask __m) const throw(); virtual ~ctype(); # 1253 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual bool do_is(mask __m, char_type __c) const; # 1272 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; # 1290 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; # 1308 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_scan_not(mask __m, const char_type* __lo, const char_type* __hi) const; # 1325 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_toupper(char_type __c) const; # 1342 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_toupper(char_type* __lo, const char_type* __hi) const; # 1358 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_tolower(char_type __c) const; # 1375 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char_type* do_tolower(char_type* __lo, const char_type* __hi) const; # 1395 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_widen(char __c) const; # 1417 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual const char* do_widen(const char* __lo, const char* __hi, char_type* __to) const; # 1440 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char do_narrow(char_type __c, char __dfault) const; # 1466 "/usr/include/c++/10/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 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 : public ctype { 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 : public ctype { public: explicit ctype_byname(const char* __s, size_t __refs = 0); explicit ctype_byname(const string& __s, size_t __refs = 0); protected: virtual ~ctype_byname(); }; } # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/ctype_inline.h" 1 3 # 37 "/usr/include/x86_64-linux-gnu/c++/10/bits/ctype_inline.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { bool ctype:: is(mask __m, char __c) const { return _M_table[static_cast(__c)] & __m; } const char* ctype:: is(const char* __low, const char* __high, mask* __vec) const { while (__low < __high) *__vec++ = _M_table[static_cast(*__low++)]; return __high; } const char* ctype:: scan_is(mask __m, const char* __low, const char* __high) const { while (__low < __high && !(_M_table[static_cast(*__low)] & __m)) ++__low; return __low; } const char* ctype:: scan_not(mask __m, const char* __low, const char* __high) const { while (__low < __high && (_M_table[static_cast(*__low)] & __m) != 0) ++__low; return __low; } } # 1539 "/usr/include/c++/10/bits/locale_facets.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { class __num_base { public: enum { _S_ominus, _S_oplus, _S_ox, _S_oX, _S_odigits, _S_odigits_end = _S_odigits + 16, _S_oudigits = _S_odigits_end, _S_oudigits_end = _S_oudigits + 16, _S_oe = _S_odigits + 14, _S_oE = _S_oudigits + 14, _S_oend = _S_oudigits_end }; static const char* _S_atoms_out; static const char* _S_atoms_in; enum { _S_iminus, _S_iplus, _S_ix, _S_iX, _S_izero, _S_ie = _S_izero + 14, _S_iE = _S_izero + 20, _S_iend = 26 }; static void _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); }; template 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 __numpunct_cache<_CharT>::~__numpunct_cache() { if (_M_allocated) { delete [] _M_grouping; delete [] _M_truename; delete [] _M_falsename; } } namespace __cxx11 { # 1669 "/usr/include/c++/10/bits/locale_facets.h" 3 template class numpunct : public locale::facet { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; typedef __numpunct_cache<_CharT> __cache_type; protected: __cache_type* _M_data; public: static locale::id id; explicit numpunct(size_t __refs = 0) : facet(__refs), _M_data(0) { _M_initialize_numpunct(); } # 1707 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit numpunct(__cache_type* __cache, size_t __refs = 0) : facet(__refs), _M_data(__cache) { _M_initialize_numpunct(); } # 1721 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit numpunct(__c_locale __cloc, size_t __refs = 0) : facet(__refs), _M_data(0) { _M_initialize_numpunct(__cloc); } # 1735 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type decimal_point() const { return this->do_decimal_point(); } # 1748 "/usr/include/c++/10/bits/locale_facets.h" 3 char_type thousands_sep() const { return this->do_thousands_sep(); } # 1779 "/usr/include/c++/10/bits/locale_facets.h" 3 string grouping() const { return this->do_grouping(); } # 1792 "/usr/include/c++/10/bits/locale_facets.h" 3 string_type truename() const { return this->do_truename(); } # 1805 "/usr/include/c++/10/bits/locale_facets.h" 3 string_type falsename() const { return this->do_falsename(); } protected: virtual ~numpunct(); # 1822 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_decimal_point() const { return _M_data->_M_decimal_point; } # 1834 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual char_type do_thousands_sep() const { return _M_data->_M_thousands_sep; } # 1847 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual string do_grouping() const { return _M_data->_M_grouping; } # 1860 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual string_type do_truename() const { return _M_data->_M_truename; } # 1873 "/usr/include/c++/10/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 locale::id numpunct<_CharT>::id; template<> numpunct::~numpunct(); template<> void numpunct::_M_initialize_numpunct(__c_locale __cloc); template<> numpunct::~numpunct(); template<> void numpunct::_M_initialize_numpunct(__c_locale __cloc); template class numpunct_byname : public numpunct<_CharT> { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; explicit numpunct_byname(const char* __s, size_t __refs = 0) : numpunct<_CharT>(__refs) { if (__builtin_strcmp(__s, "C") != 0 && __builtin_strcmp(__s, "POSIX") != 0) { __c_locale __tmp; this->_S_create_c_locale(__tmp, __s); this->_M_initialize_numpunct(__tmp); this->_S_destroy_c_locale(__tmp); } } explicit numpunct_byname(const string& __s, size_t __refs = 0) : numpunct_byname(__s.c_str(), __refs) { } protected: virtual ~numpunct_byname() { } }; } # 1951 "/usr/include/c++/10/bits/locale_facets.h" 3 template class num_get : public locale::facet { public: typedef _CharT char_type; typedef _InIter iter_type; static locale::id id; # 1972 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit num_get(size_t __refs = 0) : facet(__refs) { } # 1998 "/usr/include/c++/10/bits/locale_facets.h" 3 iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, bool& __v) const { return this->do_get(__in, __end, __io, __err, __v); } # 2035 "/usr/include/c++/10/bits/locale_facets.h" 3 iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned short& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned int& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, long long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long long& __v) const { return this->do_get(__in, __end, __io, __err, __v); } # 2095 "/usr/include/c++/10/bits/locale_facets.h" 3 iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, float& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, double& __v) const { return this->do_get(__in, __end, __io, __err, __v); } iter_type get(iter_type __in, iter_type __end, ios_base& __io, ios_base::iostate& __err, long double& __v) const { return this->do_get(__in, __end, __io, __err, __v); } # 2138 "/usr/include/c++/10/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 __attribute ((__abi_tag__ ("cxx11"))) iter_type _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, _ValueT&) const; template 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 __gnu_cxx::__enable_if::__value, int>::__type _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const { int __ret = -1; const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); if (__q) { __ret = __q - __zero; if (__ret > 15) __ret -= 6; } return __ret; } # 2211 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned short& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned int& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, long long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, unsigned long long& __v) const { return _M_extract_int(__beg, __end, __io, __err, __v); } virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, double&) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long double&) const; virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const; # 2274 "/usr/include/c++/10/bits/locale_facets.h" 3 }; template locale::id num_get<_CharT, _InIter>::id; # 2292 "/usr/include/c++/10/bits/locale_facets.h" 3 template class num_put : public locale::facet { public: typedef _CharT char_type; typedef _OutIter iter_type; static locale::id id; # 2313 "/usr/include/c++/10/bits/locale_facets.h" 3 explicit num_put(size_t __refs = 0) : facet(__refs) { } # 2331 "/usr/include/c++/10/bits/locale_facets.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const { return this->do_put(__s, __io, __fill, __v); } # 2373 "/usr/include/c++/10/bits/locale_facets.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, long __v) const { return this->do_put(__s, __io, __fill, __v); } iter_type put(iter_type __s, ios_base& __io, char_type __fill, unsigned long __v) const { return this->do_put(__s, __io, __fill, __v); } iter_type put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const { return this->do_put(__s, __io, __fill, __v); } iter_type put(iter_type __s, ios_base& __io, char_type __fill, unsigned long long __v) const { return this->do_put(__s, __io, __fill, __v); } # 2436 "/usr/include/c++/10/bits/locale_facets.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, double __v) const { return this->do_put(__s, __io, __fill, __v); } iter_type put(iter_type __s, ios_base& __io, char_type __fill, long double __v) const { return this->do_put(__s, __io, __fill, __v); } # 2461 "/usr/include/c++/10/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 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 iter_type _M_insert_int(iter_type, ios_base& __io, char_type __fill, _ValueT __v) const; void _M_group_int(const char* __grouping, size_t __grouping_size, char_type __sep, ios_base& __io, char_type* __new, char_type* __cs, int& __len) const; void _M_pad(char_type __fill, streamsize __w, ios_base& __io, char_type* __new, const char_type* __cs, int& __len) const; virtual ~num_put() { } # 2509 "/usr/include/c++/10/bits/locale_facets.h" 3 virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const; virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const { return _M_insert_int(__s, __io, __fill, __v); } virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, unsigned long __v) const { return _M_insert_int(__s, __io, __fill, __v); } virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const { return _M_insert_int(__s, __io, __fill, __v); } virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, unsigned long long __v) const { return _M_insert_int(__s, __io, __fill, __v); } virtual iter_type do_put(iter_type, ios_base&, char_type, double) const; virtual iter_type do_put(iter_type, ios_base&, char_type, long double) const; virtual iter_type do_put(iter_type, ios_base&, char_type, const void*) const; }; template locale::id num_put<_CharT, _OutIter>::id; template inline bool isspace(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::space, __c); } template inline bool isprint(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::print, __c); } template inline bool iscntrl(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::cntrl, __c); } template inline bool isupper(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::upper, __c); } template inline bool islower(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::lower, __c); } template inline bool isalpha(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::alpha, __c); } template inline bool isdigit(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::digit, __c); } template inline bool ispunct(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::punct, __c); } template inline bool isxdigit(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::xdigit, __c); } template inline bool isalnum(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::alnum, __c); } template inline bool isgraph(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::graph, __c); } template inline bool isblank(_CharT __c, const locale& __loc) { return use_facet >(__loc).is(ctype_base::blank, __c); } template inline _CharT toupper(_CharT __c, const locale& __loc) { return use_facet >(__loc).toupper(__c); } template inline _CharT tolower(_CharT __c, const locale& __loc) { return use_facet >(__loc).tolower(__c); } } # 1 "/usr/include/c++/10/bits/locale_facets.tcc" 1 3 # 33 "/usr/include/c++/10/bits/locale_facets.tcc" 3 # 34 "/usr/include/c++/10/bits/locale_facets.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct __use_cache { const _Facet* operator() (const locale& __loc) const; }; template 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*>(__caches[__i]); } }; template void __numpunct_cache<_CharT>::_M_cache(const locale& __loc) { const numpunct<_CharT>& __np = use_facet >(__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(__grouping[0]) > 0 && (__grouping[0] != __gnu_cxx::__numeric_traits::__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 >(__loc); __ct.widen(__num_base::_S_atoms_out, __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out); __ct.widen(__num_base::_S_atoms_in, __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in); _M_grouping = __grouping; _M_truename = __truename; _M_falsename = __falsename; _M_allocated = true; } catch(...) { delete [] __grouping; delete [] __truename; delete [] __falsename; throw; } } # 139 "/usr/include/c++/10/bits/locale_facets.tcc" 3 __attribute__ ((__pure__)) bool __verify_grouping(const char* __grouping, size_t __grouping_size, const string& __grouping_tmp) throw (); template __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(__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(__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(__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(__sep_pos); if (!std::__verify_grouping(__lc->_M_grouping, __lc->_M_grouping_size, __found_grouping)) __err = ios_base::failbit; } return __beg; } template template __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(__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(__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 _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, bool& __v) const { if (!(__io.flags() & ios_base::boolalpha)) { long __l = -1; __beg = _M_extract_int(__beg, __end, __io, __err, __l); if (__l == 0 || __l == 1) __v = bool(__l); else { __v = true; __err = ios_base::failbit; if (__beg == __end) __err |= ios_base::eofbit; } } else { typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); bool __testf = true; bool __testt = true; bool __donef = __lc->_M_falsename_size == 0; bool __donet = __lc->_M_truename_size == 0; bool __testeof = false; size_t __n = 0; while (!__donef || !__donet) { if (__beg == __end) { __testeof = true; break; } const char_type __c = *__beg; if (!__donef) __testf = __c == __lc->_M_falsename[__n]; if (!__testf && __donet) break; if (!__donet) __testt = __c == __lc->_M_truename[__n]; if (!__testt && __donef) break; if (!__testt && !__testf) break; ++__n; ++__beg; __donef = !__testf || __n >= __lc->_M_falsename_size; __donet = !__testt || __n >= __lc->_M_truename_size; } if (__testf && __n == __lc->_M_falsename_size && __n) { __v = false; if (__testt && __n == __lc->_M_truename_size) __err = ios_base::failbit; else __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else if (__testt && __n == __lc->_M_truename_size && __n) { __v = true; __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else { __v = false; __err = ios_base::failbit; if (__testeof) __err |= ios_base::eofbit; } } return __beg; } template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, float& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, double& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } # 735 "/usr/include/c++/10/bits/locale_facets.tcc" 3 template _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, long double& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template _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(__ul); return __beg; } template 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(__w); } template 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 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 template _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(__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 void num_put<_CharT, _OutIter>:: _M_group_float(const char* __grouping, size_t __grouping_size, _CharT __sep, const _CharT* __p, _CharT* __new, _CharT* __cs, int& __len) const { const int __declen = __p ? __p - __cs : __len; _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping, __grouping_size, __cs, __cs + __declen); int __newlen = __p2 - __new; if (__p) { char_traits<_CharT>::copy(__p2, __p, __len - __declen); __newlen += __len - __declen; } __len = __newlen; } # 971 "/usr/include/c++/10/bits/locale_facets.tcc" 3 template template _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(__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(__builtin_alloca(__cs_size)); if (__use_prec) __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __prec, __v); else __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __v); } # 1044 "/usr/include/c++/10/bits/locale_facets.tcc" 3 const ctype<_CharT>& __ctype = use_facet >(__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::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(__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 _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(__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 _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const { return _M_insert_float(__s, __io, __fill, char(), __v); } # 1169 "/usr/include/c++/10/bits/locale_facets.tcc" 3 template _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 _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, const void* __v) const { const ios_base::fmtflags __flags = __io.flags(); const ios_base::fmtflags __fmt = ~(ios_base::basefield | ios_base::uppercase); __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); typedef __gnu_cxx::__conditional_type<(sizeof(const void*) <= sizeof(unsigned long)), unsigned long, unsigned long long>::__type _UIntPtrType; __s = _M_insert_int(__s, __io, __fill, reinterpret_cast<_UIntPtrType>(__v)); __io.flags(__flags); return __s; } # 1206 "/usr/include/c++/10/bits/locale_facets.tcc" 3 template 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(__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 >(__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 _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(__gbeg[__idx]) > 0 && __gbeg[__idx] != __gnu_cxx::__numeric_traits::__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; extern template class __cxx11:: numpunct_byname; extern template class num_get; extern template class num_put; extern template class ctype_byname; extern template const ctype& use_facet >(const locale&); extern template const numpunct& use_facet >(const locale&); extern template const num_put& use_facet >(const locale&); extern template const num_get& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template class __cxx11:: numpunct; extern template class __cxx11:: numpunct_byname; extern template class num_get; extern template class num_put; extern template class ctype_byname; extern template const ctype& use_facet >(const locale&); extern template const numpunct& use_facet >(const locale&); extern template const num_put& use_facet >(const locale&); extern template const num_get& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); } # 2656 "/usr/include/c++/10/bits/locale_facets.h" 2 3 # 38 "/usr/include/c++/10/bits/basic_ios.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template inline const _Facet& __check_facet(const _Facet* __f) { if (!__f) __throw_bad_cast(); return *__f; } # 66 "/usr/include/c++/10/bits/basic_ios.h" 3 template class basic_ios : public ios_base { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef ctype<_CharT> __ctype_type; typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > __num_put_type; typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > __num_get_type; protected: basic_ostream<_CharT, _Traits>* _M_tie; mutable char_type _M_fill; mutable bool _M_fill_init; basic_streambuf<_CharT, _Traits>* _M_streambuf; const __ctype_type* _M_ctype; const __num_put_type* _M_num_put; const __num_get_type* _M_num_get; public: # 117 "/usr/include/c++/10/bits/basic_ios.h" 3 explicit operator bool() const { return !this->fail(); } bool operator!() const { return this->fail(); } # 136 "/usr/include/c++/10/bits/basic_ios.h" 3 iostate rdstate() const { return _M_streambuf_state; } # 147 "/usr/include/c++/10/bits/basic_ios.h" 3 void clear(iostate __state = goodbit); void setstate(iostate __state) { this->clear(this->rdstate() | __state); } void _M_setstate(iostate __state) { _M_streambuf_state |= __state; if (this->exceptions() & __state) throw; } bool good() const { return this->rdstate() == 0; } bool eof() const { return (this->rdstate() & eofbit) != 0; } # 200 "/usr/include/c++/10/bits/basic_ios.h" 3 bool fail() const { return (this->rdstate() & (badbit | failbit)) != 0; } bool bad() const { return (this->rdstate() & badbit) != 0; } # 221 "/usr/include/c++/10/bits/basic_ios.h" 3 iostate exceptions() const { return _M_exception; } # 256 "/usr/include/c++/10/bits/basic_ios.h" 3 void exceptions(iostate __except) { _M_exception = __except; this->clear(_M_streambuf_state); } explicit basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) { this->init(__sb); } virtual ~basic_ios() { } # 294 "/usr/include/c++/10/bits/basic_ios.h" 3 basic_ostream<_CharT, _Traits>* tie() const { return _M_tie; } # 306 "/usr/include/c++/10/bits/basic_ios.h" 3 basic_ostream<_CharT, _Traits>* tie(basic_ostream<_CharT, _Traits>* __tiestr) { basic_ostream<_CharT, _Traits>* __old = _M_tie; _M_tie = __tiestr; return __old; } basic_streambuf<_CharT, _Traits>* rdbuf() const { return _M_streambuf; } # 346 "/usr/include/c++/10/bits/basic_ios.h" 3 basic_streambuf<_CharT, _Traits>* rdbuf(basic_streambuf<_CharT, _Traits>* __sb); # 360 "/usr/include/c++/10/bits/basic_ios.h" 3 basic_ios& copyfmt(const basic_ios& __rhs); char_type fill() const { if (!_M_fill_init) { _M_fill = this->widen(' '); _M_fill_init = true; } return _M_fill; } # 389 "/usr/include/c++/10/bits/basic_ios.h" 3 char_type fill(char_type __ch) { char_type __old = this->fill(); _M_fill = __ch; return __old; } # 409 "/usr/include/c++/10/bits/basic_ios.h" 3 locale imbue(const locale& __loc); # 429 "/usr/include/c++/10/bits/basic_ios.h" 3 char narrow(char_type __c, char __dfault) const { return __check_facet(_M_ctype).narrow(__c, __dfault); } # 448 "/usr/include/c++/10/bits/basic_ios.h" 3 char_type widen(char __c) const { return __check_facet(_M_ctype).widen(__c); } protected: basic_ios() : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) { } void init(basic_streambuf<_CharT, _Traits>* __sb); basic_ios(const basic_ios&) = delete; basic_ios& operator=(const basic_ios&) = delete; void move(basic_ios& __rhs) { ios_base::_M_move(__rhs); _M_cache_locale(_M_ios_locale); this->tie(__rhs.tie(nullptr)); _M_fill = __rhs._M_fill; _M_fill_init = __rhs._M_fill_init; _M_streambuf = nullptr; } void move(basic_ios&& __rhs) { this->move(__rhs); } void swap(basic_ios& __rhs) noexcept { ios_base::_M_swap(__rhs); _M_cache_locale(_M_ios_locale); __rhs._M_cache_locale(__rhs._M_ios_locale); std::swap(_M_tie, __rhs._M_tie); std::swap(_M_fill, __rhs._M_fill); std::swap(_M_fill_init, __rhs._M_fill_init); } void set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb) { _M_streambuf = __sb; } void _M_cache_locale(const locale& __loc); }; } # 1 "/usr/include/c++/10/bits/basic_ios.tcc" 1 3 # 33 "/usr/include/c++/10/bits/basic_ios.tcc" 3 # 34 "/usr/include/c++/10/bits/basic_ios.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template void basic_ios<_CharT, _Traits>::clear(iostate __state) { if (this->rdbuf()) _M_streambuf_state = __state; else _M_streambuf_state = __state | badbit; if (this->exceptions() & this->rdstate()) __throw_ios_failure(("basic_ios::clear")); } template basic_streambuf<_CharT, _Traits>* basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) { basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; _M_streambuf = __sb; this->clear(); return __old; } template basic_ios<_CharT, _Traits>& basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) { if (this != &__rhs) { _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ? _M_local_word : new _Words[__rhs._M_word_size]; _Callback_list* __cb = __rhs._M_callbacks; if (__cb) __cb->_M_add_reference(); _M_call_callbacks(erase_event); if (_M_word != _M_local_word) { delete [] _M_word; _M_word = 0; } _M_dispose_callbacks(); _M_callbacks = __cb; for (int __i = 0; __i < __rhs._M_word_size; ++__i) __words[__i] = __rhs._M_word[__i]; _M_word = __words; _M_word_size = __rhs._M_word_size; this->flags(__rhs.flags()); this->width(__rhs.width()); this->precision(__rhs.precision()); this->tie(__rhs.tie()); this->fill(__rhs.fill()); _M_ios_locale = __rhs.getloc(); _M_cache_locale(_M_ios_locale); _M_call_callbacks(copyfmt_event); this->exceptions(__rhs.exceptions()); } return *this; } template locale basic_ios<_CharT, _Traits>::imbue(const locale& __loc) { locale __old(this->getloc()); ios_base::imbue(__loc); _M_cache_locale(__loc); if (this->rdbuf() != 0) this->rdbuf()->pubimbue(__loc); return __old; } template void basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) { ios_base::_M_init(); _M_cache_locale(_M_ios_locale); # 146 "/usr/include/c++/10/bits/basic_ios.tcc" 3 _M_fill = _CharT(); _M_fill_init = false; _M_tie = 0; _M_exception = goodbit; _M_streambuf = __sb; _M_streambuf_state = __sb ? goodbit : badbit; } template void basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) { if (__builtin_expect(has_facet<__ctype_type>(__loc), true)) _M_ctype = std::__addressof(use_facet<__ctype_type>(__loc)); else _M_ctype = 0; if (__builtin_expect(has_facet<__num_put_type>(__loc), true)) _M_num_put = std::__addressof(use_facet<__num_put_type>(__loc)); else _M_num_put = 0; if (__builtin_expect(has_facet<__num_get_type>(__loc), true)) _M_num_get = std::__addressof(use_facet<__num_get_type>(__loc)); else _M_num_get = 0; } extern template class basic_ios; extern template class basic_ios; } # 517 "/usr/include/c++/10/bits/basic_ios.h" 2 3 # 45 "/usr/include/c++/10/ios" 2 3 # 39 "/usr/include/c++/10/ostream" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 57 "/usr/include/c++/10/ostream" 3 template class basic_ostream : virtual public basic_ios<_CharT, _Traits> { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef basic_ios<_CharT, _Traits> __ios_type; typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > __num_put_type; typedef ctype<_CharT> __ctype_type; # 83 "/usr/include/c++/10/ostream" 3 explicit basic_ostream(__streambuf_type* __sb) { this->init(__sb); } virtual ~basic_ostream() { } class sentry; friend class sentry; # 107 "/usr/include/c++/10/ostream" 3 __ostream_type& operator<<(__ostream_type& (*__pf)(__ostream_type&)) { return __pf(*this); } __ostream_type& operator<<(__ios_type& (*__pf)(__ios_type&)) { __pf(*this); return *this; } __ostream_type& operator<<(ios_base& (*__pf) (ios_base&)) { __pf(*this); return *this; } # 165 "/usr/include/c++/10/ostream" 3 __ostream_type& operator<<(long __n) { return _M_insert(__n); } __ostream_type& operator<<(unsigned long __n) { return _M_insert(__n); } __ostream_type& operator<<(bool __n) { return _M_insert(__n); } __ostream_type& operator<<(short __n); __ostream_type& operator<<(unsigned short __n) { return _M_insert(static_cast(__n)); } __ostream_type& operator<<(int __n); __ostream_type& operator<<(unsigned int __n) { return _M_insert(static_cast(__n)); } __ostream_type& operator<<(long long __n) { return _M_insert(__n); } __ostream_type& operator<<(unsigned long long __n) { return _M_insert(__n); } # 219 "/usr/include/c++/10/ostream" 3 __ostream_type& operator<<(double __f) { return _M_insert(__f); } __ostream_type& operator<<(float __f) { return _M_insert(static_cast(__f)); } __ostream_type& operator<<(long double __f) { return _M_insert(__f); } # 244 "/usr/include/c++/10/ostream" 3 __ostream_type& operator<<(const void* __p) { return _M_insert(__p); } __ostream_type& operator<<(nullptr_t) { return *this << "nullptr"; } # 275 "/usr/include/c++/10/ostream" 3 __ostream_type& operator<<(__streambuf_type* __sb); # 308 "/usr/include/c++/10/ostream" 3 __ostream_type& put(char_type __c); void _M_write(const char_type* __s, streamsize __n) { const streamsize __put = this->rdbuf()->sputn(__s, __n); if (__put != __n) this->setstate(ios_base::badbit); } # 340 "/usr/include/c++/10/ostream" 3 __ostream_type& write(const char_type* __s, streamsize __n); # 353 "/usr/include/c++/10/ostream" 3 __ostream_type& flush(); # 363 "/usr/include/c++/10/ostream" 3 pos_type tellp(); # 374 "/usr/include/c++/10/ostream" 3 __ostream_type& seekp(pos_type); # 386 "/usr/include/c++/10/ostream" 3 __ostream_type& seekp(off_type, ios_base::seekdir); protected: basic_ostream() { this->init(0); } basic_ostream(basic_iostream<_CharT, _Traits>&) { } basic_ostream(const basic_ostream&) = delete; basic_ostream(basic_ostream&& __rhs) : __ios_type() { __ios_type::move(__rhs); } basic_ostream& operator=(const basic_ostream&) = delete; basic_ostream& operator=(basic_ostream&& __rhs) { swap(__rhs); return *this; } void swap(basic_ostream& __rhs) { __ios_type::swap(__rhs); } template __ostream_type& _M_insert(_ValueT __v); }; # 431 "/usr/include/c++/10/ostream" 3 template class basic_ostream<_CharT, _Traits>::sentry { bool _M_ok; basic_ostream<_CharT, _Traits>& _M_os; public: # 450 "/usr/include/c++/10/ostream" 3 explicit sentry(basic_ostream<_CharT, _Traits>& __os); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" ~sentry() { if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) { if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) _M_os.setstate(ios_base::badbit); } } #pragma GCC diagnostic pop # 482 "/usr/include/c++/10/ostream" 3 explicit operator bool() const { return _M_ok; } }; # 504 "/usr/include/c++/10/ostream" 3 template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) { return __ostream_insert(__out, &__c, 1); } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) { return (__out << __out.widen(__c)); } template inline basic_ostream& operator<<(basic_ostream& __out, char __c) { return __ostream_insert(__out, &__c, 1); } template inline basic_ostream& operator<<(basic_ostream& __out, signed char __c) { return (__out << static_cast(__c)); } template inline basic_ostream& operator<<(basic_ostream& __out, unsigned char __c) { return (__out << static_cast(__c)); } template basic_ostream& operator<<(basic_ostream&, wchar_t) = delete; template basic_ostream& operator<<(basic_ostream&, char8_t) = delete; template basic_ostream& operator<<(basic_ostream&, char16_t) = delete; template basic_ostream& operator<<(basic_ostream&, char32_t) = delete; template basic_ostream& operator<<(basic_ostream&, char8_t) = delete; template basic_ostream& operator<<(basic_ostream&, char16_t) = delete; template basic_ostream& operator<<(basic_ostream&, char32_t) = delete; # 587 "/usr/include/c++/10/ostream" 3 template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) { if (!__s) __out.setstate(ios_base::badbit); else __ostream_insert(__out, __s, static_cast(_Traits::length(__s))); return __out; } template basic_ostream<_CharT, _Traits> & operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); template inline basic_ostream& operator<<(basic_ostream& __out, const char* __s) { if (!__s) __out.setstate(ios_base::badbit); else __ostream_insert(__out, __s, static_cast(_Traits::length(__s))); return __out; } template inline basic_ostream& operator<<(basic_ostream& __out, const signed char* __s) { return (__out << reinterpret_cast(__s)); } template inline basic_ostream & operator<<(basic_ostream& __out, const unsigned char* __s) { return (__out << reinterpret_cast(__s)); } template basic_ostream& operator<<(basic_ostream&, const wchar_t*) = delete; template basic_ostream& operator<<(basic_ostream&, const char8_t*) = delete; template basic_ostream& operator<<(basic_ostream&, const char16_t*) = delete; template basic_ostream& operator<<(basic_ostream&, const char32_t*) = delete; template basic_ostream& operator<<(basic_ostream&, const char8_t*) = delete; template basic_ostream& operator<<(basic_ostream&, const char16_t*) = delete; template basic_ostream& operator<<(basic_ostream&, const char32_t*) = delete; # 679 "/usr/include/c++/10/ostream" 3 template inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) { return flush(__os.put(__os.widen('\n'))); } # 691 "/usr/include/c++/10/ostream" 3 template inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) { return __os.put(_CharT()); } template inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) { return __os.flush(); } template basic_ostream<_Ch, _Up>& __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*); template struct __is_convertible_to_basic_ostream_impl { using __ostream_type = void; }; template using __do_is_convertible_to_basic_ostream_impl = decltype(__is_convertible_to_basic_ostream_test (declval::type*>())); template struct __is_convertible_to_basic_ostream_impl <_Tp, __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>> { using __ostream_type = __do_is_convertible_to_basic_ostream_impl<_Tp>; }; template struct __is_convertible_to_basic_ostream : __is_convertible_to_basic_ostream_impl<_Tp> { public: using type = __not_::__ostream_type>>; constexpr static bool value = type::value; }; template struct __is_insertable : false_type {}; template struct __is_insertable<_Ostream, _Tp, __void_t() << declval())>> : true_type {}; template using __rvalue_ostream_type = typename __is_convertible_to_basic_ostream< _Ostream>::__ostream_type; # 765 "/usr/include/c++/10/ostream" 3 template inline typename enable_if<__and_<__not_>, __is_convertible_to_basic_ostream<_Ostream>, __is_insertable< __rvalue_ostream_type<_Ostream>, const _Tp&>>::value, __rvalue_ostream_type<_Ostream>>::type operator<<(_Ostream&& __os, const _Tp& __x) { __rvalue_ostream_type<_Ostream> __ret_os = __os; __ret_os << __x; return __ret_os; } } # 1 "/usr/include/c++/10/bits/ostream.tcc" 1 3 # 37 "/usr/include/c++/10/bits/ostream.tcc" 3 # 38 "/usr/include/c++/10/bits/ostream.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template basic_ostream<_CharT, _Traits>::sentry:: sentry(basic_ostream<_CharT, _Traits>& __os) : _M_ok(false), _M_os(__os) { if (__os.tie() && __os.good()) __os.tie()->flush(); if (__os.good()) _M_ok = true; else __os.setstate(ios_base::failbit); } template template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: _M_insert(_ValueT __v) { sentry __cerb(*this); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __num_put_type& __np = __check_facet(this->_M_num_put); if (__np.put(*this, *this, this->fill(), __v).failed()) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(short __n) { const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; if (__fmt == ios_base::oct || __fmt == ios_base::hex) return _M_insert(static_cast(static_cast(__n))); else return _M_insert(static_cast(__n)); } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(int __n) { const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; if (__fmt == ios_base::oct || __fmt == ios_base::hex) return _M_insert(static_cast(static_cast(__n))); else return _M_insert(static_cast(__n)); } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(__streambuf_type* __sbin) { ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this); if (__cerb && __sbin) { try { if (!__copy_streambufs(__sbin, this->rdbuf())) __err |= ios_base::failbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::failbit); } } else if (!__sbin) __err |= ios_base::badbit; if (__err) this->setstate(__err); return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: put(char_type __c) { sentry __cerb(*this); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __put = this->rdbuf()->sputc(__c); if (traits_type::eq_int_type(__put, traits_type::eof())) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: write(const _CharT* __s, streamsize __n) { sentry __cerb(*this); if (__cerb) { try { _M_write(__s, __n); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: flush() { ios_base::iostate __err = ios_base::goodbit; try { if (this->rdbuf() && this->rdbuf()->pubsync() == -1) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); return *this; } template typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>:: tellp() { pos_type __ret = pos_type(-1); try { if (!this->fail()) __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } return __ret; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: seekp(pos_type __pos) { ios_base::iostate __err = ios_base::goodbit; try { if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out); if (__p == pos_type(off_type(-1))) __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); return *this; } template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: seekp(off_type __off, ios_base::seekdir __dir) { ios_base::iostate __err = ios_base::goodbit; try { if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, ios_base::out); if (__p == pos_type(off_type(-1))) __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); return *this; } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) { if (!__s) __out.setstate(ios_base::badbit); else { const size_t __clen = char_traits::length(__s); try { struct __ptr_guard { _CharT *__p; __ptr_guard (_CharT *__ip): __p(__ip) { } ~__ptr_guard() { delete[] __p; } _CharT* __get() { return __p; } } __pg (new _CharT[__clen]); _CharT *__ws = __pg.__get(); for (size_t __i = 0; __i < __clen; ++__i) __ws[__i] = __out.widen(__s[__i]); __ostream_insert(__out, __ws, __clen); } catch(__cxxabiv1::__forced_unwind&) { __out._M_setstate(ios_base::badbit); throw; } catch(...) { __out._M_setstate(ios_base::badbit); } } return __out; } extern template class basic_ostream; extern template ostream& endl(ostream&); extern template ostream& ends(ostream&); extern template ostream& flush(ostream&); extern template ostream& operator<<(ostream&, char); extern template ostream& operator<<(ostream&, unsigned char); extern template ostream& operator<<(ostream&, signed char); extern template ostream& operator<<(ostream&, const char*); extern template ostream& operator<<(ostream&, const unsigned char*); extern template ostream& operator<<(ostream&, const signed char*); extern template ostream& ostream::_M_insert(long); extern template ostream& ostream::_M_insert(unsigned long); extern template ostream& ostream::_M_insert(bool); extern template ostream& ostream::_M_insert(long long); extern template ostream& ostream::_M_insert(unsigned long long); extern template ostream& ostream::_M_insert(double); extern template ostream& ostream::_M_insert(long double); extern template ostream& ostream::_M_insert(const void*); extern template class basic_ostream; extern template wostream& endl(wostream&); extern template wostream& ends(wostream&); extern template wostream& flush(wostream&); extern template wostream& operator<<(wostream&, wchar_t); extern template wostream& operator<<(wostream&, char); extern template wostream& operator<<(wostream&, const wchar_t*); extern template wostream& operator<<(wostream&, const char*); extern template wostream& wostream::_M_insert(long); extern template wostream& wostream::_M_insert(unsigned long); extern template wostream& wostream::_M_insert(bool); extern template wostream& wostream::_M_insert(long long); extern template wostream& wostream::_M_insert(unsigned long long); extern template wostream& wostream::_M_insert(double); extern template wostream& wostream::_M_insert(long double); extern template wostream& wostream::_M_insert(const void*); } # 785 "/usr/include/c++/10/ostream" 2 3 # 43 "/usr/include/c++/10/bits/unique_ptr.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template class auto_ptr; #pragma GCC diagnostic pop template struct default_delete { constexpr default_delete() noexcept = default; template>> default_delete(const default_delete<_Up>&) noexcept { } void operator()(_Tp* __ptr) const { static_assert(!is_void<_Tp>::value, "can't delete pointer to incomplete type"); static_assert(sizeof(_Tp)>0, "can't delete pointer to incomplete type"); delete __ptr; } }; template struct default_delete<_Tp[]> { public: constexpr default_delete() noexcept = default; # 109 "/usr/include/c++/10/bits/unique_ptr.h" 3 template>> default_delete(const default_delete<_Up[]>&) noexcept { } template typename enable_if::value>::type operator()(_Up* __ptr) const { static_assert(sizeof(_Tp)>0, "can't delete pointer to incomplete type"); delete [] __ptr; } }; template class __uniq_ptr_impl { template struct _Ptr { using type = _Up*; }; template struct _Ptr<_Up, _Ep, __void_t::type::pointer>> { using type = typename remove_reference<_Ep>::type::pointer; }; public: using _DeleterConstraint = enable_if< __and_<__not_>, is_default_constructible<_Dp>>::value>; using pointer = typename _Ptr<_Tp, _Dp>::type; static_assert( !is_rvalue_reference<_Dp>::value, "unique_ptr's deleter type must be a function object type" " or an lvalue reference type" ); __uniq_ptr_impl() = default; __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } template __uniq_ptr_impl(pointer __p, _Del&& __d) : _M_t(__p, std::forward<_Del>(__d)) { } __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept : _M_t(std::move(__u._M_t)) { __u._M_ptr() = nullptr; } __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept { reset(__u.release()); _M_deleter() = std::forward<_Dp>(__u._M_deleter()); return *this; } pointer& _M_ptr() { return std::get<0>(_M_t); } pointer _M_ptr() const { return std::get<0>(_M_t); } _Dp& _M_deleter() { return std::get<1>(_M_t); } const _Dp& _M_deleter() const { return std::get<1>(_M_t); } void reset(pointer __p) noexcept { const pointer __old_p = _M_ptr(); _M_ptr() = __p; if (__old_p) _M_deleter()(__old_p); } pointer release() noexcept { pointer __p = _M_ptr(); _M_ptr() = nullptr; return __p; } void swap(__uniq_ptr_impl& __rhs) noexcept { using std::swap; swap(this->_M_ptr(), __rhs._M_ptr()); swap(this->_M_deleter(), __rhs._M_deleter()); } private: tuple _M_t; }; template ::value, bool = is_move_assignable<_Dp>::value> struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = default; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; }; template struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = default; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; }; template struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = delete; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; }; template struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp> { using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; __uniq_ptr_data(__uniq_ptr_data&&) = delete; __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; }; template > class unique_ptr { template using _DeleterConstraint = typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; __uniq_ptr_data<_Tp, _Dp> _M_t; public: using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; using element_type = _Tp; using deleter_type = _Dp; private: template using __safe_conversion_up = __and_< is_convertible::pointer, pointer>, __not_> >; public: template> constexpr unique_ptr() noexcept : _M_t() { } template> explicit unique_ptr(pointer __p) noexcept : _M_t(__p) { } # 292 "/usr/include/c++/10/bits/unique_ptr.h" 3 template>> unique_ptr(pointer __p, const deleter_type& __d) noexcept : _M_t(__p, __d) { } # 304 "/usr/include/c++/10/bits/unique_ptr.h" 3 template>> unique_ptr(pointer __p, __enable_if_t::value, _Del&&> __d) noexcept : _M_t(__p, std::move(__d)) { } template::type> unique_ptr(pointer, __enable_if_t::value, _DelUnref&&>) = delete; template> constexpr unique_ptr(nullptr_t) noexcept : _M_t() { } unique_ptr(unique_ptr&&) = default; template, typename conditional::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>::type>> unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) { } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template, is_same<_Dp, default_delete<_Tp>>>> unique_ptr(auto_ptr<_Up>&& __u) noexcept; #pragma GCC diagnostic pop ~unique_ptr() noexcept { static_assert(__is_invocable::value, "unique_ptr's deleter must be invocable with a pointer"); auto& __ptr = _M_t._M_ptr(); if (__ptr != nullptr) get_deleter()(std::move(__ptr)); __ptr = pointer(); } unique_ptr& operator=(unique_ptr&&) = default; # 380 "/usr/include/c++/10/bits/unique_ptr.h" 3 template typename enable_if< __and_< __safe_conversion_up<_Up, _Ep>, is_assignable >::value, unique_ptr&>::type operator=(unique_ptr<_Up, _Ep>&& __u) noexcept { reset(__u.release()); get_deleter() = std::forward<_Ep>(__u.get_deleter()); return *this; } unique_ptr& operator=(nullptr_t) noexcept { reset(); return *this; } typename add_lvalue_reference::type operator*() const { ; return *get(); } pointer operator->() const noexcept { ; return get(); } pointer get() const noexcept { return _M_t._M_ptr(); } deleter_type& get_deleter() noexcept { return _M_t._M_deleter(); } const deleter_type& get_deleter() const noexcept { return _M_t._M_deleter(); } explicit operator bool() const noexcept { return get() == pointer() ? false : true; } pointer release() noexcept { return _M_t.release(); } void reset(pointer __p = pointer()) noexcept { static_assert(__is_invocable::value, "unique_ptr's deleter must be invocable with a pointer"); _M_t.reset(std::move(__p)); } void swap(unique_ptr& __u) noexcept { static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); _M_t.swap(__u._M_t); } unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; }; template class unique_ptr<_Tp[], _Dp> { template using _DeleterConstraint = typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; __uniq_ptr_data<_Tp, _Dp> _M_t; template using __remove_cv = typename remove_cv<_Up>::type; template using __is_derived_Tp = __and_< is_base_of<_Tp, _Up>, __not_, __remove_cv<_Up>>> >; public: using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; using element_type = _Tp; using deleter_type = _Dp; template, typename _UP_pointer = typename _UPtr::pointer, typename _UP_element_type = typename _UPtr::element_type> using __safe_conversion_up = __and_< is_array<_Up>, is_same, is_same<_UP_pointer, _UP_element_type*>, is_convertible<_UP_element_type(*)[], element_type(*)[]> >; template using __safe_conversion_raw = __and_< __or_<__or_, is_same<_Up, nullptr_t>>, __and_, is_same, is_convertible< typename remove_pointer<_Up>::type(*)[], element_type(*)[]> > > >; template> constexpr unique_ptr() noexcept : _M_t() { } # 541 "/usr/include/c++/10/bits/unique_ptr.h" 3 template, typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type> explicit unique_ptr(_Up __p) noexcept : _M_t(__p) { } # 559 "/usr/include/c++/10/bits/unique_ptr.h" 3 template, is_copy_constructible<_Del>>> unique_ptr(_Up __p, const deleter_type& __d) noexcept : _M_t(__p, __d) { } # 573 "/usr/include/c++/10/bits/unique_ptr.h" 3 template, is_move_constructible<_Del>>> unique_ptr(_Up __p, __enable_if_t::value, _Del&&> __d) noexcept : _M_t(std::move(__p), std::move(__d)) { } template::type, typename = _Require<__safe_conversion_raw<_Up>>> unique_ptr(_Up, __enable_if_t::value, _DelUnref&&>) = delete; unique_ptr(unique_ptr&&) = default; template> constexpr unique_ptr(nullptr_t) noexcept : _M_t() { } template, typename conditional::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>::type>> unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) { } ~unique_ptr() { auto& __ptr = _M_t._M_ptr(); if (__ptr != nullptr) get_deleter()(__ptr); __ptr = pointer(); } unique_ptr& operator=(unique_ptr&&) = default; # 632 "/usr/include/c++/10/bits/unique_ptr.h" 3 template typename enable_if<__and_<__safe_conversion_up<_Up, _Ep>, is_assignable >::value, unique_ptr&>::type operator=(unique_ptr<_Up, _Ep>&& __u) noexcept { reset(__u.release()); get_deleter() = std::forward<_Ep>(__u.get_deleter()); return *this; } unique_ptr& operator=(nullptr_t) noexcept { reset(); return *this; } typename std::add_lvalue_reference::type operator[](size_t __i) const { ; return get()[__i]; } pointer get() const noexcept { return _M_t._M_ptr(); } deleter_type& get_deleter() noexcept { return _M_t._M_deleter(); } const deleter_type& get_deleter() const noexcept { return _M_t._M_deleter(); } explicit operator bool() const noexcept { return get() == pointer() ? false : true; } pointer release() noexcept { return _M_t.release(); } template , __and_, is_pointer<_Up>, is_convertible< typename remove_pointer<_Up>::type(*)[], element_type(*)[] > > > >> void reset(_Up __p) noexcept { _M_t.reset(std::move(__p)); } void reset(nullptr_t = nullptr) noexcept { reset(pointer()); } void swap(unique_ptr& __u) noexcept { static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); _M_t.swap(__u._M_t); } unique_ptr(const unique_ptr&) = delete; unique_ptr& operator=(const unique_ptr&) = delete; }; template inline typename enable_if<__is_swappable<_Dp>::value>::type swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) noexcept { __x.swap(__y); } template typename enable_if::value>::type swap(unique_ptr<_Tp, _Dp>&, unique_ptr<_Tp, _Dp>&) = delete; template [[__nodiscard__]] inline bool operator==(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return __x.get() == __y.get(); } template [[__nodiscard__]] inline bool operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept { return !__x; } # 792 "/usr/include/c++/10/bits/unique_ptr.h" 3 template [[__nodiscard__]] inline bool operator<(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { typedef typename std::common_type::pointer, typename unique_ptr<_Up, _Ep>::pointer>::type _CT; return std::less<_CT>()(__x.get(), __y.get()); } template [[__nodiscard__]] inline bool operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return std::less::pointer>()(__x.get(), nullptr); } template [[__nodiscard__]] inline bool operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return std::less::pointer>()(nullptr, __x.get()); } template [[__nodiscard__]] inline bool operator<=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return !(__y < __x); } template [[__nodiscard__]] inline bool operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return !(nullptr < __x); } template [[__nodiscard__]] inline bool operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return !(__x < nullptr); } template [[__nodiscard__]] inline bool operator>(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return (__y < __x); } template [[__nodiscard__]] inline bool operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return std::less::pointer>()(nullptr, __x.get()); } template [[__nodiscard__]] inline bool operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return std::less::pointer>()(__x.get(), nullptr); } template [[__nodiscard__]] inline bool operator>=(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return !(__x < __y); } template [[__nodiscard__]] inline bool operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { return !(__x < nullptr); } template [[__nodiscard__]] inline bool operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) { return !(nullptr < __x); } template requires three_way_comparable_with::pointer, typename unique_ptr<_Up, _Ep>::pointer> inline compare_three_way_result_t::pointer, typename unique_ptr<_Up, _Ep>::pointer> operator<=>(const unique_ptr<_Tp, _Dp>& __x, const unique_ptr<_Up, _Ep>& __y) { return compare_three_way()(__x.get(), __y.get()); } template requires three_way_comparable::pointer> inline compare_three_way_result_t::pointer> operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) { using pointer = typename unique_ptr<_Tp, _Dp>::pointer; return compare_three_way()(__x.get(), static_cast(nullptr)); } template::__enable_hash_call> struct __uniq_ptr_hash : private __poison_hash<_Ptr> { size_t operator()(const _Up& __u) const noexcept(noexcept(std::declval>()(std::declval<_Ptr>()))) { return hash<_Ptr>()(__u.get()); } }; template struct __uniq_ptr_hash<_Up, _Ptr, false> : private __poison_hash<_Ptr> { }; template struct hash> : public __hash_base>, public __uniq_ptr_hash> { }; template struct _MakeUniq { typedef unique_ptr<_Tp> __single_object; }; template struct _MakeUniq<_Tp[]> { typedef unique_ptr<_Tp[]> __array; }; template struct _MakeUniq<_Tp[_Bound]> { struct __invalid_type { }; }; template inline typename _MakeUniq<_Tp>::__single_object make_unique(_Args&&... __args) { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } template inline typename _MakeUniq<_Tp>::__array make_unique(size_t __num) { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); } template inline typename _MakeUniq<_Tp>::__invalid_type make_unique(_Args&&...) = delete; template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const unique_ptr<_Tp, _Dp>& __p) requires requires { __os << __p.get(); } { __os << __p.get(); return __os; } namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::true_type { }; } } # 84 "/usr/include/c++/10/memory" 2 3 # 1 "/usr/include/c++/10/bits/shared_ptr.h" 1 3 # 52 "/usr/include/c++/10/bits/shared_ptr.h" 3 # 1 "/usr/include/c++/10/bits/shared_ptr_base.h" 1 3 # 53 "/usr/include/c++/10/bits/shared_ptr_base.h" 3 # 1 "/usr/include/c++/10/bits/allocated_ptr.h" 1 3 # 40 "/usr/include/c++/10/bits/allocated_ptr.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template struct __allocated_ptr { using pointer = typename allocator_traits<_Alloc>::pointer; using value_type = typename allocator_traits<_Alloc>::value_type; __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr) { } template>> __allocated_ptr(_Alloc& __a, _Ptr __ptr) : _M_alloc(std::__addressof(__a)), _M_ptr(pointer_traits::pointer_to(*__ptr)) { } __allocated_ptr(__allocated_ptr&& __gd) noexcept : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr) { __gd._M_ptr = nullptr; } ~__allocated_ptr() { if (_M_ptr != nullptr) std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1); } __allocated_ptr& operator=(std::nullptr_t) noexcept { _M_ptr = nullptr; return *this; } value_type* get() { return std::__to_address(_M_ptr); } private: _Alloc* _M_alloc; pointer _M_ptr; }; template __allocated_ptr<_Alloc> __allocate_guarded(_Alloc& __a) { return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) }; } } # 54 "/usr/include/c++/10/bits/shared_ptr_base.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template class auto_ptr; #pragma GCC diagnostic pop class bad_weak_ptr : public std::exception { public: virtual char const* what() const noexcept; virtual ~bad_weak_ptr() noexcept; }; inline void __throw_bad_weak_ptr() { (throw (bad_weak_ptr())); } using __gnu_cxx::_Lock_policy; using __gnu_cxx::__default_lock_policy; using __gnu_cxx::_S_single; using __gnu_cxx::_S_mutex; using __gnu_cxx::_S_atomic; template<_Lock_policy _Lp> class _Mutex_base { protected: enum { _S_need_barriers = 0 }; }; template<> class _Mutex_base<_S_mutex> : public __gnu_cxx::__mutex { protected: enum { _S_need_barriers = 1 }; }; template<_Lock_policy _Lp = __default_lock_policy> class _Sp_counted_base : public _Mutex_base<_Lp> { public: _Sp_counted_base() noexcept : _M_use_count(1), _M_weak_count(1) { } virtual ~_Sp_counted_base() noexcept { } virtual void _M_dispose() noexcept = 0; virtual void _M_destroy() noexcept { delete this; } virtual void* _M_get_deleter(const std::type_info&) noexcept = 0; void _M_add_ref_copy() { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } void _M_add_ref_lock(); bool _M_add_ref_lock_nothrow(); void _M_release() noexcept { ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) { ; _M_dispose(); if (_Mutex_base<_Lp>::_S_need_barriers) { __atomic_thread_fence (4); } ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) { ; _M_destroy(); } } } void _M_weak_add_ref() noexcept { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } void _M_weak_release() noexcept { ; if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) { ; if (_Mutex_base<_Lp>::_S_need_barriers) { __atomic_thread_fence (4); } _M_destroy(); } } long _M_get_use_count() const noexcept { return __atomic_load_n(&_M_use_count, 0); } private: _Sp_counted_base(_Sp_counted_base const&) = delete; _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; _Atomic_word _M_use_count; _Atomic_word _M_weak_count; }; template<> inline void _Sp_counted_base<_S_single>:: _M_add_ref_lock() { if (_M_use_count == 0) __throw_bad_weak_ptr(); ++_M_use_count; } template<> inline void _Sp_counted_base<_S_mutex>:: _M_add_ref_lock() { __gnu_cxx::__scoped_lock sentry(*this); if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) { _M_use_count = 0; __throw_bad_weak_ptr(); } } template<> inline void _Sp_counted_base<_S_atomic>:: _M_add_ref_lock() { _Atomic_word __count = _M_get_use_count(); do { if (__count == 0) __throw_bad_weak_ptr(); } while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, true, 4, 0)); } template<> inline bool _Sp_counted_base<_S_single>:: _M_add_ref_lock_nothrow() { if (_M_use_count == 0) return false; ++_M_use_count; return true; } template<> inline bool _Sp_counted_base<_S_mutex>:: _M_add_ref_lock_nothrow() { __gnu_cxx::__scoped_lock sentry(*this); if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) { _M_use_count = 0; return false; } return true; } template<> inline bool _Sp_counted_base<_S_atomic>:: _M_add_ref_lock_nothrow() { _Atomic_word __count = _M_get_use_count(); do { if (__count == 0) return false; } while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, true, 4, 0)); return true; } template<> inline void _Sp_counted_base<_S_single>::_M_add_ref_copy() { ++_M_use_count; } template<> inline void _Sp_counted_base<_S_single>::_M_release() noexcept { if (--_M_use_count == 0) { _M_dispose(); if (--_M_weak_count == 0) _M_destroy(); } } template<> inline void _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept { ++_M_weak_count; } template<> inline void _Sp_counted_base<_S_single>::_M_weak_release() noexcept { if (--_M_weak_count == 0) _M_destroy(); } template<> inline long _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept { return _M_use_count; } template class __shared_ptr; template class __weak_ptr; template class __enable_shared_from_this; template class shared_ptr; template class weak_ptr; template struct owner_less; template class enable_shared_from_this; template<_Lock_policy _Lp = __default_lock_policy> class __weak_count; template<_Lock_policy _Lp = __default_lock_policy> class __shared_count; template class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> { public: explicit _Sp_counted_ptr(_Ptr __p) noexcept : _M_ptr(__p) { } virtual void _M_dispose() noexcept { delete _M_ptr; } virtual void _M_destroy() noexcept { delete this; } virtual void* _M_get_deleter(const std::type_info&) noexcept { return nullptr; } _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; private: _Ptr _M_ptr; }; template<> inline void _Sp_counted_ptr::_M_dispose() noexcept { } template<> inline void _Sp_counted_ptr::_M_dispose() noexcept { } template<> inline void _Sp_counted_ptr::_M_dispose() noexcept { } template struct _Sp_ebo_helper; template struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp { explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { } static _Tp& _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } }; template struct _Sp_ebo_helper<_Nm, _Tp, false> { explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { } static _Tp& _S_get(_Sp_ebo_helper& __eboh) { return __eboh._M_tp; } private: _Tp _M_tp; }; template class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> { class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> { typedef _Sp_ebo_helper<0, _Deleter> _Del_base; typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; public: _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept : _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a) { } _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } _Ptr _M_ptr; }; public: using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>; _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept : _M_impl(__p, std::move(__d), _Alloc()) { } _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept : _M_impl(__p, std::move(__d), __a) { } ~_Sp_counted_deleter() noexcept { } virtual void _M_dispose() noexcept { _M_impl._M_del()(_M_impl._M_ptr); } virtual void _M_destroy() noexcept { __allocator_type __a(_M_impl._M_alloc()); __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; this->~_Sp_counted_deleter(); } virtual void* _M_get_deleter(const std::type_info& __ti) noexcept { return __ti == typeid(_Deleter) ? std::__addressof(_M_impl._M_del()) : nullptr; } private: _Impl _M_impl; }; struct _Sp_make_shared_tag { private: template friend class _Sp_counted_ptr_inplace; static const type_info& _S_ti() noexcept __attribute__ ((__visibility__ ("default"))) { alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { }; return reinterpret_cast(__tag); } static bool _S_eq(const type_info&) noexcept; }; template struct _Sp_alloc_shared_tag { const _Alloc& _M_a; }; template class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> { class _Impl : _Sp_ebo_helper<0, _Alloc> { typedef _Sp_ebo_helper<0, _Alloc> _A_base; public: explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } __gnu_cxx::__aligned_buffer<_Tp> _M_storage; }; public: using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>; template _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) : _M_impl(__a) { allocator_traits<_Alloc>::construct(__a, _M_ptr(), std::forward<_Args>(__args)...); } ~_Sp_counted_ptr_inplace() noexcept { } virtual void _M_dispose() noexcept { allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); } virtual void _M_destroy() noexcept { __allocator_type __a(_M_impl._M_alloc()); __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; this->~_Sp_counted_ptr_inplace(); } private: friend class __shared_count<_Lp>; virtual void* _M_get_deleter(const std::type_info& __ti) noexcept override { auto __ptr = const_cast::type*>(_M_ptr()); if (&__ti == &_Sp_make_shared_tag::_S_ti() || __ti == typeid(_Sp_make_shared_tag) ) return __ptr; return nullptr; } _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } _Impl _M_impl; }; struct __sp_array_delete { template void operator()(_Yp* __p) const { delete[] __p; } }; template<_Lock_policy _Lp> class __shared_count { template struct __not_alloc_shared_tag { using type = void; }; template struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; public: constexpr __shared_count() noexcept : _M_pi(0) { } template explicit __shared_count(_Ptr __p) : _M_pi(0) { try { _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); } catch(...) { delete __p; throw; } } template __shared_count(_Ptr __p, false_type) : __shared_count(__p) { } template __shared_count(_Ptr __p, true_type) : __shared_count(__p, __sp_array_delete{}, allocator()) { } template::type> __shared_count(_Ptr __p, _Deleter __d) : __shared_count(__p, std::move(__d), allocator()) { } template::type> __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) { typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; try { typename _Sp_cd_type::__allocator_type __a2(__a); auto __guard = std::__allocate_guarded(__a2); _Sp_cd_type* __mem = __guard.get(); ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); _M_pi = __mem; __guard = nullptr; } catch(...) { __d(__p); throw; } } template __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, _Args&&... __args) { typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; typename _Sp_cp_type::__allocator_type __a2(__a._M_a); auto __guard = std::__allocate_guarded(__a2); _Sp_cp_type* __mem = __guard.get(); auto __pi = ::new (__mem) _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); __guard = nullptr; _M_pi = __pi; __p = __pi->_M_ptr(); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template explicit __shared_count(std::auto_ptr<_Tp>&& __r); #pragma GCC diagnostic pop template explicit __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) { if (__r.get() == nullptr) return; using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; using _Del2 = typename conditional::value, reference_wrapper::type>, _Del>::type; using _Sp_cd_type = _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; using _Alloc = allocator<_Sp_cd_type>; using _Alloc_traits = allocator_traits<_Alloc>; _Alloc __a; _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); _Alloc_traits::construct(__a, __mem, __r.release(), __r.get_deleter()); _M_pi = __mem; } explicit __shared_count(const __weak_count<_Lp>& __r); explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t); ~__shared_count() noexcept { if (_M_pi != nullptr) _M_pi->_M_release(); } __shared_count(const __shared_count& __r) noexcept : _M_pi(__r._M_pi) { if (_M_pi != 0) _M_pi->_M_add_ref_copy(); } __shared_count& operator=(const __shared_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != _M_pi) { if (__tmp != 0) __tmp->_M_add_ref_copy(); if (_M_pi != 0) _M_pi->_M_release(); _M_pi = __tmp; } return *this; } void _M_swap(__shared_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; __r._M_pi = _M_pi; _M_pi = __tmp; } long _M_get_use_count() const noexcept { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } bool _M_unique() const noexcept { return this->_M_get_use_count() == 1; } void* _M_get_deleter(const std::type_info& __ti) const noexcept { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } bool _M_less(const __shared_count& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } bool _M_less(const __weak_count<_Lp>& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } friend inline bool operator==(const __shared_count& __a, const __shared_count& __b) noexcept { return __a._M_pi == __b._M_pi; } private: friend class __weak_count<_Lp>; _Sp_counted_base<_Lp>* _M_pi; }; template<_Lock_policy _Lp> class __weak_count { public: constexpr __weak_count() noexcept : _M_pi(nullptr) { } __weak_count(const __shared_count<_Lp>& __r) noexcept : _M_pi(__r._M_pi) { if (_M_pi != nullptr) _M_pi->_M_weak_add_ref(); } __weak_count(const __weak_count& __r) noexcept : _M_pi(__r._M_pi) { if (_M_pi != nullptr) _M_pi->_M_weak_add_ref(); } __weak_count(__weak_count&& __r) noexcept : _M_pi(__r._M_pi) { __r._M_pi = nullptr; } ~__weak_count() noexcept { if (_M_pi != nullptr) _M_pi->_M_weak_release(); } __weak_count& operator=(const __shared_count<_Lp>& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != nullptr) __tmp->_M_weak_add_ref(); if (_M_pi != nullptr) _M_pi->_M_weak_release(); _M_pi = __tmp; return *this; } __weak_count& operator=(const __weak_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; if (__tmp != nullptr) __tmp->_M_weak_add_ref(); if (_M_pi != nullptr) _M_pi->_M_weak_release(); _M_pi = __tmp; return *this; } __weak_count& operator=(__weak_count&& __r) noexcept { if (_M_pi != nullptr) _M_pi->_M_weak_release(); _M_pi = __r._M_pi; __r._M_pi = nullptr; return *this; } void _M_swap(__weak_count& __r) noexcept { _Sp_counted_base<_Lp>* __tmp = __r._M_pi; __r._M_pi = _M_pi; _M_pi = __tmp; } long _M_get_use_count() const noexcept { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; } bool _M_less(const __weak_count& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } bool _M_less(const __shared_count<_Lp>& __rhs) const noexcept { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } friend inline bool operator==(const __weak_count& __a, const __weak_count& __b) noexcept { return __a._M_pi == __b._M_pi; } private: friend class __shared_count<_Lp>; _Sp_counted_base<_Lp>* _M_pi; }; template<_Lock_policy _Lp> inline __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) : _M_pi(__r._M_pi) { if (_M_pi != nullptr) _M_pi->_M_add_ref_lock(); else __throw_bad_weak_ptr(); } template<_Lock_policy _Lp> inline __shared_count<_Lp>:: __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) : _M_pi(__r._M_pi) { if (_M_pi != nullptr) if (!_M_pi->_M_add_ref_lock_nothrow()) _M_pi = nullptr; } template struct __sp_compatible_with : false_type { }; template struct __sp_compatible_with<_Yp*, _Tp*> : is_convertible<_Yp*, _Tp*>::type { }; template struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> : true_type { }; template struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> : true_type { }; template struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> : true_type { }; template struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> : true_type { }; template struct __sp_is_constructible_arrN : false_type { }; template struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type { }; template struct __sp_is_constructible_arr : false_type { }; template struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> : is_convertible<_Yp(*)[], _Up(*)[]>::type { }; template struct __sp_is_constructible; template struct __sp_is_constructible<_Up[_Nm], _Yp> : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type { }; template struct __sp_is_constructible<_Up[], _Yp> : __sp_is_constructible_arr<_Up, _Yp>::type { }; template struct __sp_is_constructible : is_convertible<_Yp*, _Tp*>::type { }; template::value, bool = is_void<_Tp>::value> class __shared_ptr_access { public: using element_type = _Tp; element_type& operator*() const noexcept { ; return *_M_get(); } element_type* operator->() const noexcept { ; return _M_get(); } private: element_type* _M_get() const noexcept { return static_cast*>(this)->get(); } }; template class __shared_ptr_access<_Tp, _Lp, false, true> { public: using element_type = _Tp; element_type* operator->() const noexcept { auto __ptr = static_cast*>(this)->get(); ; return __ptr; } }; template class __shared_ptr_access<_Tp, _Lp, true, false> { public: using element_type = typename remove_extent<_Tp>::type; # 1068 "/usr/include/c++/10/bits/shared_ptr_base.h" 3 element_type& operator[](ptrdiff_t __i) const { ; ; return _M_get()[__i]; } private: element_type* _M_get() const noexcept { return static_cast*>(this)->get(); } }; template class __shared_ptr : public __shared_ptr_access<_Tp, _Lp> { public: using element_type = typename remove_extent<_Tp>::type; private: template using _SafeConv = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; template using _Compatible = typename enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; template using _Assignable = _Compatible<_Yp, __shared_ptr&>; template::pointer> using _UniqCompatible = typename enable_if<__and_< __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*> >::value, _Res>::type; template using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; public: using weak_type = __weak_ptr<_Tp, _Lp>; constexpr __shared_ptr() noexcept : _M_ptr(0), _M_refcount() { } template> explicit __shared_ptr(_Yp* __p) : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) { static_assert( !is_void<_Yp>::value, "incomplete type" ); static_assert( sizeof(_Yp) > 0, "incomplete type" ); _M_enable_shared_from_this_with(__p); } template> __shared_ptr(_Yp* __p, _Deleter __d) : _M_ptr(__p), _M_refcount(__p, std::move(__d)) { static_assert(__is_invocable<_Deleter&, _Yp*&>::value, "deleter expression d(p) is well-formed"); _M_enable_shared_from_this_with(__p); } template> __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) { static_assert(__is_invocable<_Deleter&, _Yp*&>::value, "deleter expression d(p) is well-formed"); _M_enable_shared_from_this_with(__p); } template __shared_ptr(nullptr_t __p, _Deleter __d) : _M_ptr(0), _M_refcount(__p, std::move(__d)) { } template __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a)) { } template __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r, element_type* __p) noexcept : _M_ptr(__p), _M_refcount(__r._M_refcount) { } template __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r, element_type* __p) noexcept : _M_ptr(__p), _M_refcount() { _M_refcount._M_swap(__r._M_refcount); __r._M_ptr = 0; } __shared_ptr(const __shared_ptr&) noexcept = default; __shared_ptr& operator=(const __shared_ptr&) noexcept = default; ~__shared_ptr() = default; template> __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) { } __shared_ptr(__shared_ptr&& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount() { _M_refcount._M_swap(__r._M_refcount); __r._M_ptr = 0; } template> __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount() { _M_refcount._M_swap(__r._M_refcount); __r._M_ptr = 0; } template> explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) : _M_refcount(__r._M_refcount) { _M_ptr = __r._M_ptr; } template> __shared_ptr(unique_ptr<_Yp, _Del>&& __r) : _M_ptr(__r.get()), _M_refcount() { auto __raw = __to_address(__r.get()); _M_refcount = __shared_count<_Lp>(std::move(__r)); _M_enable_shared_from_this_with(__raw); } # 1244 "/usr/include/c++/10/bits/shared_ptr_base.h" 3 #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template> __shared_ptr(auto_ptr<_Yp>&& __r); #pragma GCC diagnostic pop constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } template _Assignable<_Yp> operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept { _M_ptr = __r._M_ptr; _M_refcount = __r._M_refcount; return *this; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template _Assignable<_Yp> operator=(auto_ptr<_Yp>&& __r) { __shared_ptr(std::move(__r)).swap(*this); return *this; } #pragma GCC diagnostic pop __shared_ptr& operator=(__shared_ptr&& __r) noexcept { __shared_ptr(std::move(__r)).swap(*this); return *this; } template _Assignable<_Yp> operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept { __shared_ptr(std::move(__r)).swap(*this); return *this; } template _UniqAssignable<_Yp, _Del> operator=(unique_ptr<_Yp, _Del>&& __r) { __shared_ptr(std::move(__r)).swap(*this); return *this; } void reset() noexcept { __shared_ptr().swap(*this); } template _SafeConv<_Yp> reset(_Yp* __p) { ; __shared_ptr(__p).swap(*this); } template _SafeConv<_Yp> reset(_Yp* __p, _Deleter __d) { __shared_ptr(__p, std::move(__d)).swap(*this); } template _SafeConv<_Yp> reset(_Yp* __p, _Deleter __d, _Alloc __a) { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } element_type* get() const noexcept { return _M_ptr; } explicit operator bool() const { return _M_ptr == 0 ? false : true; } bool unique() const noexcept { return _M_refcount._M_unique(); } long use_count() const noexcept { return _M_refcount._M_get_use_count(); } void swap(__shared_ptr<_Tp, _Lp>& __other) noexcept { std::swap(_M_ptr, __other._M_ptr); _M_refcount._M_swap(__other._M_refcount); } # 1356 "/usr/include/c++/10/bits/shared_ptr_base.h" 3 template bool owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } template bool owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } protected: template __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...) { _M_enable_shared_from_this_with(_M_ptr); } template friend __shared_ptr<_Tp1, _Lp1> __allocate_shared(const _Alloc& __a, _Args&&... __args); __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) : _M_refcount(__r._M_refcount, std::nothrow) { _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; } friend class __weak_ptr<_Tp, _Lp>; private: template using __esft_base_t = decltype(__enable_shared_from_this_base( std::declval&>(), std::declval<_Yp*>())); template struct __has_esft_base : false_type { }; template struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> : __not_> { }; template::type> typename enable_if<__has_esft_base<_Yp2>::value>::type _M_enable_shared_from_this_with(_Yp* __p) noexcept { if (auto __base = __enable_shared_from_this_base(_M_refcount, __p)) __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); } template::type> typename enable_if::value>::type _M_enable_shared_from_this_with(_Yp*) noexcept { } void* _M_get_deleter(const std::type_info& __ti) const noexcept { return _M_refcount._M_get_deleter(__ti); } template friend class __shared_ptr; template friend class __weak_ptr; template friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; template friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept; element_type* _M_ptr; __shared_count<_Lp> _M_refcount; }; template inline bool operator==(const __shared_ptr<_Tp1, _Lp>& __a, const __shared_ptr<_Tp2, _Lp>& __b) noexcept { return __a.get() == __b.get(); } template inline bool operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { return !__a; } template inline strong_ordering operator<=>(const __shared_ptr<_Tp, _Lp>& __a, const __shared_ptr<_Up, _Lp>& __b) noexcept { return compare_three_way()(__a.get(), __b.get()); } template inline strong_ordering operator<=>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept { using pointer = typename __shared_ptr<_Tp, _Lp>::element_type*; return compare_three_way()(__a.get(), static_cast(nullptr)); } # 1561 "/usr/include/c++/10/bits/shared_ptr_base.h" 3 template inline void swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept { __a.swap(__b); } # 1573 "/usr/include/c++/10/bits/shared_ptr_base.h" 3 template inline __shared_ptr<_Tp, _Lp> static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; return _Sp(__r, static_cast(__r.get())); } template inline __shared_ptr<_Tp, _Lp> const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; return _Sp(__r, const_cast(__r.get())); } template inline __shared_ptr<_Tp, _Lp> dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; if (auto* __p = dynamic_cast(__r.get())) return _Sp(__r, __p); return _Sp(); } template inline __shared_ptr<_Tp, _Lp> reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept { using _Sp = __shared_ptr<_Tp, _Lp>; return _Sp(__r, reinterpret_cast(__r.get())); } template class __weak_ptr { template using _Compatible = typename enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; template using _Assignable = _Compatible<_Yp, __weak_ptr&>; public: using element_type = typename remove_extent<_Tp>::type; constexpr __weak_ptr() noexcept : _M_ptr(nullptr), _M_refcount() { } __weak_ptr(const __weak_ptr&) noexcept = default; ~__weak_ptr() = default; # 1655 "/usr/include/c++/10/bits/shared_ptr_base.h" 3 template> __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept : _M_refcount(__r._M_refcount) { _M_ptr = __r.lock().get(); } template> __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) { } __weak_ptr(__weak_ptr&& __r) noexcept : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount)) { __r._M_ptr = nullptr; } template> __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount)) { __r._M_ptr = nullptr; } __weak_ptr& operator=(const __weak_ptr& __r) noexcept = default; template _Assignable<_Yp> operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept { _M_ptr = __r.lock().get(); _M_refcount = __r._M_refcount; return *this; } template _Assignable<_Yp> operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept { _M_ptr = __r._M_ptr; _M_refcount = __r._M_refcount; return *this; } __weak_ptr& operator=(__weak_ptr&& __r) noexcept { _M_ptr = __r._M_ptr; _M_refcount = std::move(__r._M_refcount); __r._M_ptr = nullptr; return *this; } template _Assignable<_Yp> operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept { _M_ptr = __r.lock().get(); _M_refcount = std::move(__r._M_refcount); __r._M_ptr = nullptr; return *this; } __shared_ptr<_Tp, _Lp> lock() const noexcept { return __shared_ptr(*this, std::nothrow); } long use_count() const noexcept { return _M_refcount._M_get_use_count(); } bool expired() const noexcept { return _M_refcount._M_get_use_count() == 0; } template bool owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } template bool owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept { return _M_refcount._M_less(__rhs._M_refcount); } void reset() noexcept { __weak_ptr().swap(*this); } void swap(__weak_ptr& __s) noexcept { std::swap(_M_ptr, __s._M_ptr); _M_refcount._M_swap(__s._M_refcount); } private: void _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept { if (use_count() == 0) { _M_ptr = __ptr; _M_refcount = __refcount; } } template friend class __shared_ptr; template friend class __weak_ptr; friend class __enable_shared_from_this<_Tp, _Lp>; friend class enable_shared_from_this<_Tp>; element_type* _M_ptr; __weak_count<_Lp> _M_refcount; }; template inline void swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept { __a.swap(__b); } template struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept { return __lhs.owner_before(__rhs); } bool operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept { return __lhs.owner_before(__rhs); } bool operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept { return __lhs.owner_before(__rhs); } }; template<> struct _Sp_owner_less { template auto operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept -> decltype(__lhs.owner_before(__rhs)) { return __lhs.owner_before(__rhs); } using is_transparent = void; }; template struct owner_less<__shared_ptr<_Tp, _Lp>> : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> { }; template struct owner_less<__weak_ptr<_Tp, _Lp>> : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> { }; template class __enable_shared_from_this { protected: constexpr __enable_shared_from_this() noexcept { } __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } __enable_shared_from_this& operator=(const __enable_shared_from_this&) noexcept { return *this; } ~__enable_shared_from_this() { } public: __shared_ptr<_Tp, _Lp> shared_from_this() { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } __shared_ptr shared_from_this() const { return __shared_ptr(this->_M_weak_this); } __weak_ptr<_Tp, _Lp> weak_from_this() noexcept { return this->_M_weak_this; } __weak_ptr weak_from_this() const noexcept { return this->_M_weak_this; } private: template void _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept { _M_weak_this._M_assign(__p, __n); } friend const __enable_shared_from_this* __enable_shared_from_this_base(const __shared_count<_Lp>&, const __enable_shared_from_this* __p) { return __p; } template friend class __shared_ptr; mutable __weak_ptr<_Tp, _Lp> _M_weak_this; }; template inline __shared_ptr<_Tp, _Lp> __allocate_shared(const _Alloc& __a, _Args&&... __args) { return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a}, std::forward<_Args>(__args)...); } template inline __shared_ptr<_Tp, _Lp> __make_shared(_Args&&... __args) { typedef typename std::remove_const<_Tp>::type _Tp_nc; return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), std::forward<_Args>(__args)...); } template struct hash<__shared_ptr<_Tp, _Lp>> : public __hash_base> { size_t operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept { return hash::element_type*>()( __s.get()); } }; } # 53 "/usr/include/c++/10/bits/shared_ptr.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 67 "/usr/include/c++/10/bits/shared_ptr.h" 3 template inline std::basic_ostream<_Ch, _Tr>& operator<<(std::basic_ostream<_Ch, _Tr>& __os, const __shared_ptr<_Tp, _Lp>& __p) { __os << __p.get(); return __os; } template inline _Del* get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } template inline _Del* get_deleter(const shared_ptr<_Tp>& __p) noexcept { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } # 120 "/usr/include/c++/10/bits/shared_ptr.h" 3 template class shared_ptr : public __shared_ptr<_Tp> { template using _Constructible = typename enable_if< is_constructible<__shared_ptr<_Tp>, _Args...>::value >::type; template using _Assignable = typename enable_if< is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& >::type; public: using element_type = typename __shared_ptr<_Tp>::element_type; using weak_type = weak_ptr<_Tp>; constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } shared_ptr(const shared_ptr&) noexcept = default; template> explicit shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } # 174 "/usr/include/c++/10/bits/shared_ptr.h" 3 template> shared_ptr(_Yp* __p, _Deleter __d) : __shared_ptr<_Tp>(__p, std::move(__d)) { } # 192 "/usr/include/c++/10/bits/shared_ptr.h" 3 template shared_ptr(nullptr_t __p, _Deleter __d) : __shared_ptr<_Tp>(__p, std::move(__d)) { } # 211 "/usr/include/c++/10/bits/shared_ptr.h" 3 template> shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } # 231 "/usr/include/c++/10/bits/shared_ptr.h" 3 template shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } # 255 "/usr/include/c++/10/bits/shared_ptr.h" 3 template shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept : __shared_ptr<_Tp>(__r, __p) { } # 282 "/usr/include/c++/10/bits/shared_ptr.h" 3 template shared_ptr(shared_ptr<_Yp>&& __r, element_type* __p) noexcept : __shared_ptr<_Tp>(std::move(__r), __p) { } # 293 "/usr/include/c++/10/bits/shared_ptr.h" 3 template&>> shared_ptr(const shared_ptr<_Yp>& __r) noexcept : __shared_ptr<_Tp>(__r) { } shared_ptr(shared_ptr&& __r) noexcept : __shared_ptr<_Tp>(std::move(__r)) { } template>> shared_ptr(shared_ptr<_Yp>&& __r) noexcept : __shared_ptr<_Tp>(std::move(__r)) { } # 323 "/usr/include/c++/10/bits/shared_ptr.h" 3 template&>> explicit shared_ptr(const weak_ptr<_Yp>& __r) : __shared_ptr<_Tp>(__r) { } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template>> shared_ptr(auto_ptr<_Yp>&& __r); #pragma GCC diagnostic pop template>> shared_ptr(unique_ptr<_Yp, _Del>&& __r) : __shared_ptr<_Tp>(std::move(__r)) { } # 356 "/usr/include/c++/10/bits/shared_ptr.h" 3 constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } shared_ptr& operator=(const shared_ptr&) noexcept = default; template _Assignable&> operator=(const shared_ptr<_Yp>& __r) noexcept { this->__shared_ptr<_Tp>::operator=(__r); return *this; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" template _Assignable> operator=(auto_ptr<_Yp>&& __r) { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } #pragma GCC diagnostic pop shared_ptr& operator=(shared_ptr&& __r) noexcept { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } template _Assignable> operator=(shared_ptr<_Yp>&& __r) noexcept { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } template _Assignable> operator=(unique_ptr<_Yp, _Del>&& __r) { this->__shared_ptr<_Tp>::operator=(std::move(__r)); return *this; } private: template shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...) { } template friend shared_ptr<_Yp> allocate_shared(const _Alloc& __a, _Args&&... __args); shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) : __shared_ptr<_Tp>(__r, std::nothrow) { } friend class weak_ptr<_Tp>; }; template shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; template shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>; template [[__nodiscard__]] inline bool operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { return __a.get() == __b.get(); } template [[__nodiscard__]] inline bool operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { return !__a; } template inline strong_ordering operator<=>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept { return compare_three_way()(__a.get(), __b.get()); } template inline strong_ordering operator<=>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept { using pointer = typename shared_ptr<_Tp>::element_type*; return compare_three_way()(__a.get(), static_cast(nullptr)); } # 571 "/usr/include/c++/10/bits/shared_ptr.h" 3 template inline void swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept { __a.swap(__b); } template inline shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(__r, static_cast(__r.get())); } template inline shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(__r, const_cast(__r.get())); } template inline shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; if (auto* __p = dynamic_cast(__r.get())) return _Sp(__r, __p); return _Sp(); } template inline shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(__r, reinterpret_cast(__r.get())); } template inline shared_ptr<_Tp> static_pointer_cast(shared_ptr<_Up>&& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(std::move(__r), static_cast(__r.get())); } template inline shared_ptr<_Tp> const_pointer_cast(shared_ptr<_Up>&& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(std::move(__r), const_cast(__r.get())); } template inline shared_ptr<_Tp> dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept { using _Sp = shared_ptr<_Tp>; if (auto* __p = dynamic_cast(__r.get())) return _Sp(std::move(__r), __p); return _Sp(); } template inline shared_ptr<_Tp> reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept { using _Sp = shared_ptr<_Tp>; return _Sp(std::move(__r), reinterpret_cast(__r.get())); } # 684 "/usr/include/c++/10/bits/shared_ptr.h" 3 template class weak_ptr : public __weak_ptr<_Tp> { template using _Constructible = typename enable_if< is_constructible<__weak_ptr<_Tp>, _Arg>::value >::type; template using _Assignable = typename enable_if< is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& >::type; public: constexpr weak_ptr() noexcept = default; template&>> weak_ptr(const shared_ptr<_Yp>& __r) noexcept : __weak_ptr<_Tp>(__r) { } weak_ptr(const weak_ptr&) noexcept = default; template&>> weak_ptr(const weak_ptr<_Yp>& __r) noexcept : __weak_ptr<_Tp>(__r) { } weak_ptr(weak_ptr&&) noexcept = default; template>> weak_ptr(weak_ptr<_Yp>&& __r) noexcept : __weak_ptr<_Tp>(std::move(__r)) { } weak_ptr& operator=(const weak_ptr& __r) noexcept = default; template _Assignable&> operator=(const weak_ptr<_Yp>& __r) noexcept { this->__weak_ptr<_Tp>::operator=(__r); return *this; } template _Assignable&> operator=(const shared_ptr<_Yp>& __r) noexcept { this->__weak_ptr<_Tp>::operator=(__r); return *this; } weak_ptr& operator=(weak_ptr&& __r) noexcept = default; template _Assignable> operator=(weak_ptr<_Yp>&& __r) noexcept { this->__weak_ptr<_Tp>::operator=(std::move(__r)); return *this; } shared_ptr<_Tp> lock() const noexcept { return shared_ptr<_Tp>(*this, std::nothrow); } }; template weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; template inline void swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept { __a.swap(__b); } template struct owner_less; template<> struct owner_less : _Sp_owner_less { }; template struct owner_less> : public _Sp_owner_less, weak_ptr<_Tp>> { }; template struct owner_less> : public _Sp_owner_less, shared_ptr<_Tp>> { }; template class enable_shared_from_this { protected: constexpr enable_shared_from_this() noexcept { } enable_shared_from_this(const enable_shared_from_this&) noexcept { } enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept { return *this; } ~enable_shared_from_this() { } public: shared_ptr<_Tp> shared_from_this() { return shared_ptr<_Tp>(this->_M_weak_this); } shared_ptr shared_from_this() const { return shared_ptr(this->_M_weak_this); } weak_ptr<_Tp> weak_from_this() noexcept { return this->_M_weak_this; } weak_ptr weak_from_this() const noexcept { return this->_M_weak_this; } private: template void _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept { _M_weak_this._M_assign(__p, __n); } friend const enable_shared_from_this* __enable_shared_from_this_base(const __shared_count<>&, const enable_shared_from_this* __p) { return __p; } template friend class __shared_ptr; mutable weak_ptr<_Tp> _M_weak_this; }; # 855 "/usr/include/c++/10/bits/shared_ptr.h" 3 template inline shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&&... __args) { return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, std::forward<_Args>(__args)...); } # 870 "/usr/include/c++/10/bits/shared_ptr.h" 3 template inline shared_ptr<_Tp> make_shared(_Args&&... __args) { typedef typename std::remove_cv<_Tp>::type _Tp_nc; return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(), std::forward<_Args>(__args)...); } template struct hash> : public __hash_base> { size_t operator()(const shared_ptr<_Tp>& __s) const noexcept { return std::hash::element_type*>()(__s.get()); } }; namespace __detail::__variant { template struct _Never_valueless_alt; template struct _Never_valueless_alt> : std::true_type { }; template struct _Never_valueless_alt> : std::true_type { }; } } # 85 "/usr/include/c++/10/memory" 2 3 # 1 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 1 3 # 33 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3 # 1 "/usr/include/c++/10/bits/atomic_base.h" 1 3 # 33 "/usr/include/c++/10/bits/atomic_base.h" 3 # 34 "/usr/include/c++/10/bits/atomic_base.h" 3 # 1 "/usr/include/c++/10/bits/atomic_lockfree_defines.h" 1 3 # 33 "/usr/include/c++/10/bits/atomic_lockfree_defines.h" 3 # 34 "/usr/include/c++/10/bits/atomic_lockfree_defines.h" 3 # 38 "/usr/include/c++/10/bits/atomic_base.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 57 "/usr/include/c++/10/bits/atomic_base.h" 3 enum class memory_order : int { relaxed, consume, acquire, release, acq_rel, seq_cst }; inline constexpr memory_order memory_order_relaxed = memory_order::relaxed; inline constexpr memory_order memory_order_consume = memory_order::consume; inline constexpr memory_order memory_order_acquire = memory_order::acquire; inline constexpr memory_order memory_order_release = memory_order::release; inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel; inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst; # 85 "/usr/include/c++/10/bits/atomic_base.h" 3 enum __memory_order_modifier { __memory_order_mask = 0x0ffff, __memory_order_modifier_mask = 0xffff0000, __memory_order_hle_acquire = 0x10000, __memory_order_hle_release = 0x20000 }; constexpr memory_order operator|(memory_order __m, __memory_order_modifier __mod) { return memory_order(int(__m) | int(__mod)); } constexpr memory_order operator&(memory_order __m, __memory_order_modifier __mod) { return memory_order(int(__m) & int(__mod)); } constexpr memory_order __cmpexch_failure_order2(memory_order __m) noexcept { return __m == memory_order_acq_rel ? memory_order_acquire : __m == memory_order_release ? memory_order_relaxed : __m; } constexpr memory_order __cmpexch_failure_order(memory_order __m) noexcept { return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) | __memory_order_modifier(__m & __memory_order_modifier_mask)); } inline __attribute__((__always_inline__)) void atomic_thread_fence(memory_order __m) noexcept { __atomic_thread_fence(int(__m)); } inline __attribute__((__always_inline__)) void atomic_signal_fence(memory_order __m) noexcept { __atomic_signal_fence(int(__m)); } template inline _Tp kill_dependency(_Tp __y) noexcept { _Tp __ret(__y); return __ret; } template struct __atomic_base; # 151 "/usr/include/c++/10/bits/atomic_base.h" 3 template struct atomic; template struct atomic<_Tp*>; typedef bool __atomic_flag_data_type; # 174 "/usr/include/c++/10/bits/atomic_base.h" 3 extern "C" { struct __atomic_flag_base { __atomic_flag_data_type _M_i = {}; }; } struct atomic_flag : public __atomic_flag_base { atomic_flag() noexcept = default; ~atomic_flag() noexcept = default; atomic_flag(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) volatile = delete; constexpr atomic_flag(bool __i) noexcept : __atomic_flag_base{ _S_init(__i) } { } inline __attribute__((__always_inline__)) bool test_and_set(memory_order __m = memory_order_seq_cst) noexcept { return __atomic_test_and_set (&_M_i, int(__m)); } inline __attribute__((__always_inline__)) bool test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_test_and_set (&_M_i, int(__m)); } inline __attribute__((__always_inline__)) void clear(memory_order __m = memory_order_seq_cst) noexcept { memory_order __b = __m & __memory_order_mask; ; ; ; __atomic_clear (&_M_i, int(__m)); } inline __attribute__((__always_inline__)) void clear(memory_order __m = memory_order_seq_cst) volatile noexcept { memory_order __b = __m & __memory_order_mask; ; ; ; __atomic_clear (&_M_i, int(__m)); } private: static constexpr __atomic_flag_data_type _S_init(bool __i) { return __i ? 1 : 0; } }; # 264 "/usr/include/c++/10/bits/atomic_base.h" 3 template struct __atomic_base { using value_type = _ITp; using difference_type = value_type; private: typedef _ITp __int_type; static constexpr int _S_alignment = sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); alignas(_S_alignment) __int_type _M_i = 0; public: __atomic_base() noexcept = default; ~__atomic_base() noexcept = default; __atomic_base(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } operator __int_type() const noexcept { return load(); } operator __int_type() const volatile noexcept { return load(); } __int_type operator=(__int_type __i) noexcept { store(__i); return __i; } __int_type operator=(__int_type __i) volatile noexcept { store(__i); return __i; } __int_type operator++(int) noexcept { return fetch_add(1); } __int_type operator++(int) volatile noexcept { return fetch_add(1); } __int_type operator--(int) noexcept { return fetch_sub(1); } __int_type operator--(int) volatile noexcept { return fetch_sub(1); } __int_type operator++() noexcept { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator++() volatile noexcept { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator--() noexcept { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator--() volatile noexcept { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } __int_type operator+=(__int_type __i) noexcept { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator+=(__int_type __i) volatile noexcept { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator-=(__int_type __i) noexcept { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator-=(__int_type __i) volatile noexcept { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator&=(__int_type __i) noexcept { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator&=(__int_type __i) volatile noexcept { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator|=(__int_type __i) noexcept { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator|=(__int_type __i) volatile noexcept { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator^=(__int_type __i) noexcept { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } __int_type operator^=(__int_type __i) volatile noexcept { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } bool is_lock_free() const volatile noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } inline __attribute__((__always_inline__)) void store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { memory_order __b = __m & __memory_order_mask; ; ; ; __atomic_store_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) void store(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { memory_order __b = __m & __memory_order_mask; ; ; ; __atomic_store_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type load(memory_order __m = memory_order_seq_cst) const noexcept { memory_order __b = __m & __memory_order_mask; ; ; return __atomic_load_n(&_M_i, int(__m)); } inline __attribute__((__always_inline__)) __int_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { memory_order __b = __m & __memory_order_mask; ; ; return __atomic_load_n(&_M_i, int(__m)); } inline __attribute__((__always_inline__)) __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type exchange(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { memory_order __b2 = __m2 & __memory_order_mask; memory_order __b1 = __m1 & __memory_order_mask; ; ; ; return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept { memory_order __b2 = __m2 & __memory_order_mask; memory_order __b1 = __m1 & __memory_order_mask; ; ; ; return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__i1, __i2, __m, __cmpexch_failure_order(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_weak(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__i1, __i2, __m, __cmpexch_failure_order(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept { memory_order __b2 = __m2 & __memory_order_mask; memory_order __b1 = __m1 & __memory_order_mask; ; ; ; return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept { memory_order __b2 = __m2 & __memory_order_mask; memory_order __b1 = __m1 & __memory_order_mask; ; ; ; return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__i1, __i2, __m, __cmpexch_failure_order(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__int_type& __i1, __int_type __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__i1, __i2, __m, __cmpexch_failure_order(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_add(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_sub(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_and(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_and(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_and(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_or(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_or(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_or(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } inline __attribute__((__always_inline__)) __int_type fetch_xor(__int_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } }; template struct __atomic_base<_PTp*> { private: typedef _PTp* __pointer_type; __pointer_type _M_p = nullptr; constexpr ptrdiff_t _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } constexpr ptrdiff_t _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } public: __atomic_base() noexcept = default; ~__atomic_base() noexcept = default; __atomic_base(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) = delete; __atomic_base& operator=(const __atomic_base&) volatile = delete; constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } operator __pointer_type() const noexcept { return load(); } operator __pointer_type() const volatile noexcept { return load(); } __pointer_type operator=(__pointer_type __p) noexcept { store(__p); return __p; } __pointer_type operator=(__pointer_type __p) volatile noexcept { store(__p); return __p; } __pointer_type operator++(int) noexcept { return fetch_add(1); } __pointer_type operator++(int) volatile noexcept { return fetch_add(1); } __pointer_type operator--(int) noexcept { return fetch_sub(1); } __pointer_type operator--(int) volatile noexcept { return fetch_sub(1); } __pointer_type operator++() noexcept { return __atomic_add_fetch(&_M_p, _M_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator++() volatile noexcept { return __atomic_add_fetch(&_M_p, _M_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator--() noexcept { return __atomic_sub_fetch(&_M_p, _M_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator--() volatile noexcept { return __atomic_sub_fetch(&_M_p, _M_type_size(1), int(memory_order_seq_cst)); } __pointer_type operator+=(ptrdiff_t __d) noexcept { return __atomic_add_fetch(&_M_p, _M_type_size(__d), int(memory_order_seq_cst)); } __pointer_type operator+=(ptrdiff_t __d) volatile noexcept { return __atomic_add_fetch(&_M_p, _M_type_size(__d), int(memory_order_seq_cst)); } __pointer_type operator-=(ptrdiff_t __d) noexcept { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), int(memory_order_seq_cst)); } __pointer_type operator-=(ptrdiff_t __d) volatile noexcept { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), int(memory_order_seq_cst)); } bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_M_p), reinterpret_cast(-__alignof(_M_p))); } bool is_lock_free() const volatile noexcept { return __atomic_is_lock_free(sizeof(_M_p), reinterpret_cast(-__alignof(_M_p))); } inline __attribute__((__always_inline__)) void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { memory_order __b = __m & __memory_order_mask; ; ; ; __atomic_store_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { memory_order __b = __m & __memory_order_mask; ; ; ; __atomic_store_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { memory_order __b = __m & __memory_order_mask; ; ; return __atomic_load_n(&_M_p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { memory_order __b = __m & __memory_order_mask; ; ; return __atomic_load_n(&_M_p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_exchange_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_exchange_n(&_M_p, __p, int(__m)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { memory_order __b2 = __m2 & __memory_order_mask; memory_order __b1 = __m1 & __memory_order_mask; ; ; ; return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { memory_order __b2 = __m2 & __memory_order_mask; memory_order __b1 = __m1 & __memory_order_mask; ; ; ; return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, int(__m1), int(__m2)); } inline __attribute__((__always_inline__)) __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } inline __attribute__((__always_inline__)) __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } inline __attribute__((__always_inline__)) __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } inline __attribute__((__always_inline__)) __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } }; namespace __atomic_impl { template using _Val = remove_volatile_t<_Tp>; template using _Diff = conditional_t, ptrdiff_t, _Val<_Tp>>; template inline __attribute__((__always_inline__)) bool is_lock_free() noexcept { return __atomic_is_lock_free(_Size, reinterpret_cast(-_Align)); } template inline __attribute__((__always_inline__)) void store(_Tp* __ptr, _Val<_Tp> __t, memory_order __m) noexcept { __atomic_store(__ptr, std::__addressof(__t), int(__m)); } template inline __attribute__((__always_inline__)) _Val<_Tp> load(const _Tp* __ptr, memory_order __m) noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; auto* __dest = reinterpret_cast<_Val<_Tp>*>(__buf); __atomic_load(__ptr, __dest, int(__m)); return *__dest; } template inline __attribute__((__always_inline__)) _Val<_Tp> exchange(_Tp* __ptr, _Val<_Tp> __desired, memory_order __m) noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; auto* __dest = reinterpret_cast<_Val<_Tp>*>(__buf); __atomic_exchange(__ptr, std::__addressof(__desired), __dest, int(__m)); return *__dest; } template inline __attribute__((__always_inline__)) bool compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected, _Val<_Tp> __desired, memory_order __success, memory_order __failure) noexcept { return __atomic_compare_exchange(__ptr, std::__addressof(__expected), std::__addressof(__desired), true, int(__success), int(__failure)); } template inline __attribute__((__always_inline__)) bool compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected, _Val<_Tp> __desired, memory_order __success, memory_order __failure) noexcept { return __atomic_compare_exchange(__ptr, std::__addressof(__expected), std::__addressof(__desired), false, int(__success), int(__failure)); } template inline __attribute__((__always_inline__)) _Tp fetch_add(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept { return __atomic_fetch_add(__ptr, __i, int(__m)); } template inline __attribute__((__always_inline__)) _Tp fetch_sub(_Tp* __ptr, _Diff<_Tp> __i, memory_order __m) noexcept { return __atomic_fetch_sub(__ptr, __i, int(__m)); } template inline __attribute__((__always_inline__)) _Tp fetch_and(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept { return __atomic_fetch_and(__ptr, __i, int(__m)); } template inline __attribute__((__always_inline__)) _Tp fetch_or(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept { return __atomic_fetch_or(__ptr, __i, int(__m)); } template inline __attribute__((__always_inline__)) _Tp fetch_xor(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept { return __atomic_fetch_xor(__ptr, __i, int(__m)); } template inline __attribute__((__always_inline__)) _Tp __add_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept { return __atomic_add_fetch(__ptr, __i, 5); } template inline __attribute__((__always_inline__)) _Tp __sub_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept { return __atomic_sub_fetch(__ptr, __i, 5); } template inline __attribute__((__always_inline__)) _Tp __and_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept { return __atomic_and_fetch(__ptr, __i, 5); } template inline __attribute__((__always_inline__)) _Tp __or_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept { return __atomic_or_fetch(__ptr, __i, 5); } template inline __attribute__((__always_inline__)) _Tp __xor_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept { return __atomic_xor_fetch(__ptr, __i, 5); } template _Tp __fetch_add_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept { _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); _Val<_Tp> __newval = __oldval + __i; while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, memory_order_relaxed)) __newval = __oldval + __i; return __oldval; } template _Tp __fetch_sub_flt(_Tp* __ptr, _Val<_Tp> __i, memory_order __m) noexcept { _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); _Val<_Tp> __newval = __oldval - __i; while (!compare_exchange_weak(__ptr, __oldval, __newval, __m, memory_order_relaxed)) __newval = __oldval - __i; return __oldval; } template _Tp __add_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept { _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); _Val<_Tp> __newval = __oldval + __i; while (!compare_exchange_weak(__ptr, __oldval, __newval, memory_order_seq_cst, memory_order_relaxed)) __newval = __oldval + __i; return __newval; } template _Tp __sub_fetch_flt(_Tp* __ptr, _Val<_Tp> __i) noexcept { _Val<_Tp> __oldval = load(__ptr, memory_order_relaxed); _Val<_Tp> __newval = __oldval - __i; while (!compare_exchange_weak(__ptr, __oldval, __newval, memory_order_seq_cst, memory_order_relaxed)) __newval = __oldval - __i; return __newval; } } template struct __atomic_float { static_assert(is_floating_point_v<_Fp>); static constexpr size_t _S_alignment = __alignof__(_Fp); public: using value_type = _Fp; using difference_type = value_type; static constexpr bool is_always_lock_free = __atomic_always_lock_free(sizeof(_Fp), 0); __atomic_float() = default; constexpr __atomic_float(_Fp __t) : _M_fp(__t) { } __atomic_float(const __atomic_float&) = delete; __atomic_float& operator=(const __atomic_float&) = delete; __atomic_float& operator=(const __atomic_float&) volatile = delete; _Fp operator=(_Fp __t) volatile noexcept { this->store(__t); return __t; } _Fp operator=(_Fp __t) noexcept { this->store(__t); return __t; } bool is_lock_free() const volatile noexcept { return __atomic_impl::is_lock_free(); } bool is_lock_free() const noexcept { return __atomic_impl::is_lock_free(); } void store(_Fp __t, memory_order __m = memory_order_seq_cst) volatile noexcept { __atomic_impl::store(&_M_fp, __t, __m); } void store(_Fp __t, memory_order __m = memory_order_seq_cst) noexcept { __atomic_impl::store(&_M_fp, __t, __m); } _Fp load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return __atomic_impl::load(&_M_fp, __m); } _Fp load(memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::load(&_M_fp, __m); } operator _Fp() const volatile noexcept { return this->load(); } operator _Fp() const noexcept { return this->load(); } _Fp exchange(_Fp __desired, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_impl::exchange(&_M_fp, __desired, __m); } _Fp exchange(_Fp __desired, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::exchange(&_M_fp, __desired, __m); } bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __success, memory_order __failure) noexcept { return __atomic_impl::compare_exchange_weak(&_M_fp, __expected, __desired, __success, __failure); } bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __success, memory_order __failure) volatile noexcept { return __atomic_impl::compare_exchange_weak(&_M_fp, __expected, __desired, __success, __failure); } bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __success, memory_order __failure) noexcept { return __atomic_impl::compare_exchange_strong(&_M_fp, __expected, __desired, __success, __failure); } bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __success, memory_order __failure) volatile noexcept { return __atomic_impl::compare_exchange_strong(&_M_fp, __expected, __desired, __success, __failure); } bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) noexcept { return compare_exchange_weak(__expected, __desired, __order, __cmpexch_failure_order(__order)); } bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__expected, __desired, __order, __cmpexch_failure_order(__order)); } bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) noexcept { return compare_exchange_strong(__expected, __desired, __order, __cmpexch_failure_order(__order)); } bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__expected, __desired, __order, __cmpexch_failure_order(__order)); } value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); } value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_impl::__fetch_add_flt(&_M_fp, __i, __m); } value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) noexcept { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); } value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return __atomic_impl::__fetch_sub_flt(&_M_fp, __i, __m); } value_type operator+=(value_type __i) noexcept { return __atomic_impl::__add_fetch_flt(&_M_fp, __i); } value_type operator+=(value_type __i) volatile noexcept { return __atomic_impl::__add_fetch_flt(&_M_fp, __i); } value_type operator-=(value_type __i) noexcept { return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); } value_type operator-=(value_type __i) volatile noexcept { return __atomic_impl::__sub_fetch_flt(&_M_fp, __i); } private: alignas(_S_alignment) _Fp _M_fp = 0; }; template, bool = is_floating_point_v<_Tp>> struct __atomic_ref; template struct __atomic_ref<_Tp, false, false> { static_assert(is_trivially_copyable_v<_Tp>); static constexpr int _S_min_alignment = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 ? 0 : sizeof(_Tp); public: using value_type = _Tp; static constexpr bool is_always_lock_free = __atomic_always_lock_free(sizeof(_Tp), 0); static constexpr size_t required_alignment = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); __atomic_ref& operator=(const __atomic_ref&) = delete; explicit __atomic_ref(_Tp& __t) : _M_ptr(std::__addressof(__t)) { ; } __atomic_ref(const __atomic_ref&) noexcept = default; _Tp operator=(_Tp __t) const noexcept { this->store(__t); return __t; } operator _Tp() const noexcept { return this->load(); } bool is_lock_free() const noexcept { return __atomic_impl::is_lock_free(); } void store(_Tp __t, memory_order __m = memory_order_seq_cst) const noexcept { __atomic_impl::store(_M_ptr, __t, __m); } _Tp load(memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::load(_M_ptr, __m); } _Tp exchange(_Tp __desired, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::exchange(_M_ptr, __desired, __m); } bool compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_weak(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_strong(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_weak(__expected, __desired, __order, __cmpexch_failure_order(__order)); } bool compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_strong(__expected, __desired, __order, __cmpexch_failure_order(__order)); } private: _Tp* _M_ptr; }; template struct __atomic_ref<_Tp, true, false> { static_assert(is_integral_v<_Tp>); public: using value_type = _Tp; using difference_type = value_type; static constexpr bool is_always_lock_free = __atomic_always_lock_free(sizeof(_Tp), 0); static constexpr size_t required_alignment = sizeof(_Tp) > alignof(_Tp) ? sizeof(_Tp) : alignof(_Tp); __atomic_ref() = delete; __atomic_ref& operator=(const __atomic_ref&) = delete; explicit __atomic_ref(_Tp& __t) : _M_ptr(&__t) { ; } __atomic_ref(const __atomic_ref&) noexcept = default; _Tp operator=(_Tp __t) const noexcept { this->store(__t); return __t; } operator _Tp() const noexcept { return this->load(); } bool is_lock_free() const noexcept { return __atomic_impl::is_lock_free(); } void store(_Tp __t, memory_order __m = memory_order_seq_cst) const noexcept { __atomic_impl::store(_M_ptr, __t, __m); } _Tp load(memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::load(_M_ptr, __m); } _Tp exchange(_Tp __desired, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::exchange(_M_ptr, __desired, __m); } bool compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_weak(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_strong(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_weak(__expected, __desired, __order, __cmpexch_failure_order(__order)); } bool compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_strong(__expected, __desired, __order, __cmpexch_failure_order(__order)); } value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_add(_M_ptr, __i, __m); } value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_sub(_M_ptr, __i, __m); } value_type fetch_and(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_and(_M_ptr, __i, __m); } value_type fetch_or(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_or(_M_ptr, __i, __m); } value_type fetch_xor(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_xor(_M_ptr, __i, __m); } inline __attribute__((__always_inline__)) value_type operator++(int) const noexcept { return fetch_add(1); } inline __attribute__((__always_inline__)) value_type operator--(int) const noexcept { return fetch_sub(1); } value_type operator++() const noexcept { return __atomic_impl::__add_fetch(_M_ptr, value_type(1)); } value_type operator--() const noexcept { return __atomic_impl::__sub_fetch(_M_ptr, value_type(1)); } value_type operator+=(value_type __i) const noexcept { return __atomic_impl::__add_fetch(_M_ptr, __i); } value_type operator-=(value_type __i) const noexcept { return __atomic_impl::__sub_fetch(_M_ptr, __i); } value_type operator&=(value_type __i) const noexcept { return __atomic_impl::__and_fetch(_M_ptr, __i); } value_type operator|=(value_type __i) const noexcept { return __atomic_impl::__or_fetch(_M_ptr, __i); } value_type operator^=(value_type __i) const noexcept { return __atomic_impl::__xor_fetch(_M_ptr, __i); } private: _Tp* _M_ptr; }; template struct __atomic_ref<_Fp, false, true> { static_assert(is_floating_point_v<_Fp>); public: using value_type = _Fp; using difference_type = value_type; static constexpr bool is_always_lock_free = __atomic_always_lock_free(sizeof(_Fp), 0); static constexpr size_t required_alignment = __alignof__(_Fp); __atomic_ref() = delete; __atomic_ref& operator=(const __atomic_ref&) = delete; explicit __atomic_ref(_Fp& __t) : _M_ptr(&__t) { ; } __atomic_ref(const __atomic_ref&) noexcept = default; _Fp operator=(_Fp __t) const noexcept { this->store(__t); return __t; } operator _Fp() const noexcept { return this->load(); } bool is_lock_free() const noexcept { return __atomic_impl::is_lock_free(); } void store(_Fp __t, memory_order __m = memory_order_seq_cst) const noexcept { __atomic_impl::store(_M_ptr, __t, __m); } _Fp load(memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::load(_M_ptr, __m); } _Fp exchange(_Fp __desired, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::exchange(_M_ptr, __desired, __m); } bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_weak(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_strong(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_weak(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_weak(__expected, __desired, __order, __cmpexch_failure_order(__order)); } bool compare_exchange_strong(_Fp& __expected, _Fp __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_strong(__expected, __desired, __order, __cmpexch_failure_order(__order)); } value_type fetch_add(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::__fetch_add_flt(_M_ptr, __i, __m); } value_type fetch_sub(value_type __i, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::__fetch_sub_flt(_M_ptr, __i, __m); } value_type operator+=(value_type __i) const noexcept { return __atomic_impl::__add_fetch_flt(_M_ptr, __i); } value_type operator-=(value_type __i) const noexcept { return __atomic_impl::__sub_fetch_flt(_M_ptr, __i); } private: _Fp* _M_ptr; }; template struct __atomic_ref<_Tp*, false, false> { public: using value_type = _Tp*; using difference_type = ptrdiff_t; static constexpr bool is_always_lock_free = 2 == 2; static constexpr size_t required_alignment = __alignof__(_Tp*); __atomic_ref() = delete; __atomic_ref& operator=(const __atomic_ref&) = delete; explicit __atomic_ref(_Tp*& __t) : _M_ptr(std::__addressof(__t)) { ; } __atomic_ref(const __atomic_ref&) noexcept = default; _Tp* operator=(_Tp* __t) const noexcept { this->store(__t); return __t; } operator _Tp*() const noexcept { return this->load(); } bool is_lock_free() const noexcept { return __atomic_impl::is_lock_free(); } void store(_Tp* __t, memory_order __m = memory_order_seq_cst) const noexcept { __atomic_impl::store(_M_ptr, __t, __m); } _Tp* load(memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::load(_M_ptr, __m); } _Tp* exchange(_Tp* __desired, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::exchange(_M_ptr, __desired, __m); } bool compare_exchange_weak(_Tp*& __expected, _Tp* __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_weak(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_strong(_Tp*& __expected, _Tp* __desired, memory_order __success, memory_order __failure) const noexcept { return __atomic_impl::compare_exchange_strong(_M_ptr, __expected, __desired, __success, __failure); } bool compare_exchange_weak(_Tp*& __expected, _Tp* __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_weak(__expected, __desired, __order, __cmpexch_failure_order(__order)); } bool compare_exchange_strong(_Tp*& __expected, _Tp* __desired, memory_order __order = memory_order_seq_cst) const noexcept { return compare_exchange_strong(__expected, __desired, __order, __cmpexch_failure_order(__order)); } inline __attribute__((__always_inline__)) value_type fetch_add(difference_type __d, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_add(_M_ptr, _S_type_size(__d), __m); } inline __attribute__((__always_inline__)) value_type fetch_sub(difference_type __d, memory_order __m = memory_order_seq_cst) const noexcept { return __atomic_impl::fetch_sub(_M_ptr, _S_type_size(__d), __m); } value_type operator++(int) const noexcept { return fetch_add(1); } value_type operator--(int) const noexcept { return fetch_sub(1); } value_type operator++() const noexcept { return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(1)); } value_type operator--() const noexcept { return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(1)); } value_type operator+=(difference_type __d) const noexcept { return __atomic_impl::__add_fetch(_M_ptr, _S_type_size(__d)); } value_type operator-=(difference_type __d) const noexcept { return __atomic_impl::__sub_fetch(_M_ptr, _S_type_size(__d)); } private: static constexpr ptrdiff_t _S_type_size(ptrdiff_t __d) noexcept { static_assert(is_object_v<_Tp>); return __d * sizeof(_Tp); } _Tp** _M_ptr; }; } # 34 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 47 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3 struct _Sp_locker { _Sp_locker(const _Sp_locker&) = delete; _Sp_locker& operator=(const _Sp_locker&) = delete; explicit _Sp_locker(const void*) noexcept; _Sp_locker(const void*, const void*) noexcept; ~_Sp_locker(); private: unsigned char _M_key1; unsigned char _M_key2; }; # 74 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3 template inline bool atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p) { return __gthread_active_p() == 0; } template inline bool atomic_is_lock_free(const shared_ptr<_Tp>* __p) { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); } # 101 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3 template inline shared_ptr<_Tp> atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) { _Sp_locker __lock{__p}; return *__p; } template inline shared_ptr<_Tp> atomic_load(const shared_ptr<_Tp>* __p) { return std::atomic_load_explicit(__p, memory_order_seq_cst); } template inline __shared_ptr<_Tp, _Lp> atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order) { _Sp_locker __lock{__p}; return *__p; } template inline __shared_ptr<_Tp, _Lp> atomic_load(const __shared_ptr<_Tp, _Lp>* __p) { return std::atomic_load_explicit(__p, memory_order_seq_cst); } # 137 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3 template inline void atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); } template inline void atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } template inline void atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); } template inline void atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } # 174 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3 template inline shared_ptr<_Tp> atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); return __r; } template inline shared_ptr<_Tp> atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) { return std::atomic_exchange_explicit(__p, std::move(__r), memory_order_seq_cst); } template inline __shared_ptr<_Tp, _Lp> atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r, memory_order) { _Sp_locker __lock{__p}; __p->swap(__r); return __r; } template inline __shared_ptr<_Tp, _Lp> atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) { return std::atomic_exchange_explicit(__p, std::move(__r), memory_order_seq_cst); } # 223 "/usr/include/c++/10/bits/shared_ptr_atomic.h" 3 template bool atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) { shared_ptr<_Tp> __x; _Sp_locker __lock{__p, __v}; owner_less> __less; if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) { __x = std::move(*__p); *__p = std::move(__w); return true; } __x = std::move(*__v); *__v = *__p; return false; } template inline bool atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order __success, memory_order __failure) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), __success, __failure); } template inline bool atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) { return std::atomic_compare_exchange_weak_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } template bool atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w, memory_order, memory_order) { __shared_ptr<_Tp, _Lp> __x; _Sp_locker __lock{__p, __v}; owner_less<__shared_ptr<_Tp, _Lp>> __less; if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) { __x = std::move(*__p); *__p = std::move(__w); return true; } __x = std::move(*__v); *__v = *__p; return false; } template inline bool atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w, memory_order __success, memory_order __failure) { return std::atomic_compare_exchange_strong_explicit(__p, __v, std::move(__w), __success, __failure); } template inline bool atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp>* __v, __shared_ptr<_Tp, _Lp> __w) { return std::atomic_compare_exchange_weak_explicit(__p, __v, std::move(__w), memory_order_seq_cst, memory_order_seq_cst); } } # 86 "/usr/include/c++/10/memory" 2 3 # 1 "/usr/include/c++/10/backward/auto_ptr.h" 1 3 # 36 "/usr/include/c++/10/backward/auto_ptr.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 47 "/usr/include/c++/10/backward/auto_ptr.h" 3 template struct auto_ptr_ref { _Tp1* _M_ptr; explicit auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } } __attribute__ ((__deprecated__)); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" # 88 "/usr/include/c++/10/backward/auto_ptr.h" 3 template class auto_ptr { private: _Tp* _M_ptr; public: typedef _Tp element_type; explicit auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } # 114 "/usr/include/c++/10/backward/auto_ptr.h" 3 auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } # 126 "/usr/include/c++/10/backward/auto_ptr.h" 3 template auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } # 137 "/usr/include/c++/10/backward/auto_ptr.h" 3 auto_ptr& operator=(auto_ptr& __a) throw() { reset(__a.release()); return *this; } # 154 "/usr/include/c++/10/backward/auto_ptr.h" 3 template auto_ptr& operator=(auto_ptr<_Tp1>& __a) throw() { reset(__a.release()); return *this; } # 172 "/usr/include/c++/10/backward/auto_ptr.h" 3 ~auto_ptr() { delete _M_ptr; } # 182 "/usr/include/c++/10/backward/auto_ptr.h" 3 element_type& operator*() const throw() { ; return *_M_ptr; } element_type* operator->() const throw() { ; return _M_ptr; } # 212 "/usr/include/c++/10/backward/auto_ptr.h" 3 element_type* get() const throw() { return _M_ptr; } # 226 "/usr/include/c++/10/backward/auto_ptr.h" 3 element_type* release() throw() { element_type* __tmp = _M_ptr; _M_ptr = 0; return __tmp; } # 241 "/usr/include/c++/10/backward/auto_ptr.h" 3 void reset(element_type* __p = 0) throw() { if (__p != _M_ptr) { delete _M_ptr; _M_ptr = __p; } } # 266 "/usr/include/c++/10/backward/auto_ptr.h" 3 auto_ptr(auto_ptr_ref __ref) throw() : _M_ptr(__ref._M_ptr) { } auto_ptr& operator=(auto_ptr_ref __ref) throw() { if (__ref._M_ptr != this->get()) { delete _M_ptr; _M_ptr = __ref._M_ptr; } return *this; } template operator auto_ptr_ref<_Tp1>() throw() { return auto_ptr_ref<_Tp1>(this->release()); } template operator auto_ptr<_Tp1>() throw() { return auto_ptr<_Tp1>(this->release()); } } __attribute__ ((__deprecated__)); template<> class auto_ptr { public: typedef void element_type; } __attribute__ ((__deprecated__)); template<_Lock_policy _Lp> template inline __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r) : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get())) { __r.release(); } template template inline __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r) : _M_ptr(__r.get()), _M_refcount() { static_assert( sizeof(_Tp1) > 0, "incomplete type" ); _Tp1* __tmp = __r.get(); _M_refcount = __shared_count<_Lp>(std::move(__r)); _M_enable_shared_from_this_with(__tmp); } template template inline shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r) : __shared_ptr<_Tp>(std::move(__r)) { } template template inline unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept : _M_t(__u.release(), deleter_type()) { } #pragma GCC diagnostic pop } # 88 "/usr/include/c++/10/memory" 2 3 # 96 "/usr/include/c++/10/memory" 3 # 1 "/usr/include/c++/10/bit" 1 3 # 32 "/usr/include/c++/10/bit" 3 # 33 "/usr/include/c++/10/bit" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 54 "/usr/include/c++/10/bit" 3 template constexpr _Tp __rotl(_Tp __x, int __s) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); else return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); } template constexpr _Tp __rotr(_Tp __x, int __s) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; const int __r = __s % _Nd; if (__r == 0) return __x; else if (__r > 0) return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); else return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); } template constexpr int __countl_zero(_Tp __x) noexcept { using __gnu_cxx::__int_traits; constexpr auto _Nd = __int_traits<_Tp>::__digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = __int_traits::__digits; constexpr auto _Nd_ul = __int_traits::__digits; constexpr auto _Nd_u = __int_traits::__digits; if constexpr (_Nd <= _Nd_u) { constexpr int __diff = _Nd_u - _Nd; return __builtin_clz(__x) - __diff; } else if constexpr (_Nd <= _Nd_ul) { constexpr int __diff = _Nd_ul - _Nd; return __builtin_clzl(__x) - __diff; } else if constexpr (_Nd <= _Nd_ull) { constexpr int __diff = _Nd_ull - _Nd; return __builtin_clzll(__x) - __diff; } else { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); unsigned long long __high = __x >> _Nd_ull; if (__high != 0) { constexpr int __diff = (2 * _Nd_ull) - _Nd; return __builtin_clzll(__high) - __diff; } constexpr auto __max_ull = __int_traits::__max; unsigned long long __low = __x & __max_ull; return (_Nd - _Nd_ull) + __builtin_clzll(__low); } } template constexpr int __countl_one(_Tp __x) noexcept { return std::__countl_zero<_Tp>((_Tp)~__x); } template constexpr int __countr_zero(_Tp __x) noexcept { using __gnu_cxx::__int_traits; constexpr auto _Nd = __int_traits<_Tp>::__digits; if (__x == 0) return _Nd; constexpr auto _Nd_ull = __int_traits::__digits; constexpr auto _Nd_ul = __int_traits::__digits; constexpr auto _Nd_u = __int_traits::__digits; if constexpr (_Nd <= _Nd_u) return __builtin_ctz(__x); else if constexpr (_Nd <= _Nd_ul) return __builtin_ctzl(__x); else if constexpr (_Nd <= _Nd_ull) return __builtin_ctzll(__x); else { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = __int_traits::__max; unsigned long long __low = __x & __max_ull; if (__low != 0) return __builtin_ctzll(__low); unsigned long long __high = __x >> _Nd_ull; return __builtin_ctzll(__high) + _Nd_ull; } } template constexpr int __countr_one(_Tp __x) noexcept { return std::__countr_zero((_Tp)~__x); } template constexpr int __popcount(_Tp __x) noexcept { using __gnu_cxx::__int_traits; constexpr auto _Nd = __int_traits<_Tp>::__digits; constexpr auto _Nd_ull = __int_traits::__digits; constexpr auto _Nd_ul = __int_traits::__digits; constexpr auto _Nd_u = __int_traits::__digits; if constexpr (_Nd <= _Nd_u) return __builtin_popcount(__x); else if constexpr (_Nd <= _Nd_ul) return __builtin_popcountl(__x); else if constexpr (_Nd <= _Nd_ull) return __builtin_popcountll(__x); else { static_assert(_Nd <= (2 * _Nd_ull), "Maximum supported integer size is 128-bit"); constexpr auto __max_ull = __int_traits::__max; unsigned long long __low = __x & __max_ull; unsigned long long __high = __x >> _Nd_ull; return __builtin_popcountll(__low) + __builtin_popcountll(__high); } } template constexpr bool __has_single_bit(_Tp __x) noexcept { return std::__popcount(__x) == 1; } template constexpr _Tp __bit_ceil(_Tp __x) noexcept { using __gnu_cxx::__int_traits; constexpr auto _Nd = __int_traits<_Tp>::__digits; if (__x == 0 || __x == 1) return 1; auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); if (!__builtin_is_constant_evaluated()) { ; } using __promoted_type = decltype(__x << 1); if constexpr (!is_same<__promoted_type, _Tp>::value) { const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; } return (_Tp)1u << __shift_exponent; } template constexpr _Tp __bit_floor(_Tp __x) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; if (__x == 0) return 0; return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); } template constexpr _Tp __bit_width(_Tp __x) noexcept { constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; return _Nd - std::__countl_zero(__x); } # 268 "/usr/include/c++/10/bit" 3 template using _If_is_unsigned_integer = enable_if_t<__is_unsigned_integer<_Tp>::value, _Up>; template [[nodiscard]] constexpr _If_is_unsigned_integer<_Tp> rotl(_Tp __x, int __s) noexcept { return std::__rotl(__x, __s); } template [[nodiscard]] constexpr _If_is_unsigned_integer<_Tp> rotr(_Tp __x, int __s) noexcept { return std::__rotr(__x, __s); } template constexpr _If_is_unsigned_integer<_Tp, int> countl_zero(_Tp __x) noexcept { return std::__countl_zero(__x); } template constexpr _If_is_unsigned_integer<_Tp, int> countl_one(_Tp __x) noexcept { return std::__countl_one(__x); } template constexpr _If_is_unsigned_integer<_Tp, int> countr_zero(_Tp __x) noexcept { return std::__countr_zero(__x); } template constexpr _If_is_unsigned_integer<_Tp, int> countr_one(_Tp __x) noexcept { return std::__countr_one(__x); } template constexpr _If_is_unsigned_integer<_Tp, int> popcount(_Tp __x) noexcept { return std::__popcount(__x); } template constexpr _If_is_unsigned_integer<_Tp, bool> has_single_bit(_Tp __x) noexcept { return std::__has_single_bit(__x); } template constexpr _If_is_unsigned_integer<_Tp> bit_ceil(_Tp __x) noexcept { return std::__bit_ceil(__x); } template constexpr _If_is_unsigned_integer<_Tp> bit_floor(_Tp __x) noexcept { return std::__bit_floor(__x); } template constexpr _If_is_unsigned_integer<_Tp> bit_width(_Tp __x) noexcept { return std::__bit_width(__x); } enum class endian { little = 1234, big = 4321, native = 1234 }; } # 97 "/usr/include/c++/10/memory" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 122 "/usr/include/c++/10/memory" 3 inline void* align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept { const auto __intptr = reinterpret_cast(__ptr); const auto __aligned = (__intptr - 1u + __align) & -__align; const auto __diff = __aligned - __intptr; if ((__size + __diff) > __space) return nullptr; else { __space -= __diff; return __ptr = reinterpret_cast(__aligned); } } # 158 "/usr/include/c++/10/memory" 3 enum class pointer_safety { relaxed, preferred, strict }; inline void declare_reachable(void*) { } template inline _Tp* undeclare_reachable(_Tp* __p) { return __p; } inline void declare_no_pointers(char*, size_t) { } inline void undeclare_no_pointers(char*, size_t) { } inline pointer_safety get_pointer_safety() noexcept { return pointer_safety::relaxed; } # 194 "/usr/include/c++/10/memory" 3 template [[nodiscard,__gnu__::__always_inline__]] constexpr _Tp* assume_aligned(_Tp* __ptr) noexcept { static_assert(std::has_single_bit(_Align)); if (std::is_constant_evaluated()) return __ptr; else { ; return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Align)); } } template struct __is_pair : false_type { }; template struct __is_pair> : true_type { }; template struct __is_pair> : true_type { }; template>>, typename _Alloc, typename... _Args> constexpr auto __uses_alloc_args(const _Alloc& __a, _Args&&... __args) noexcept { if constexpr (uses_allocator_v, _Alloc>) { if constexpr (is_constructible_v<_Tp, allocator_arg_t, const _Alloc&, _Args...>) { return tuple( 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 concept _Std_pair = __is_pair<_Tp>::value; # 269 "/usr/include/c++/10/memory" 3 template constexpr auto uses_allocator_construction_args(const _Alloc& __a, _Args&&... __args) noexcept requires (! _Std_pair<_Tp>) { return std::__uses_alloc_args<_Tp>(__a, 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 _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(__args1)...); }, std::forward<_Tuple1>(__x)), std::apply([&__a](auto&&... __args2) { return std::uses_allocator_construction_args<_Tp2>( __a, std::forward(__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::move(__pr).first), std::uses_allocator_construction_args<_Tp2>(__a, std::move(__pr).second)); } template inline _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 inline _Tp* uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __a, _Args&&... __args) { return std::apply([&](auto&&... __xs) { return std::construct_at(__p, std::forward(__xs)...); }, std::uses_allocator_construction_args<_Tp>(__a, std::forward<_Args>(__args)...)); } } # 422 "/usr/include/c++/10/memory" 3 # 1 "/usr/include/c++/10/pstl/glue_memory_defs.h" 1 3 # 13 "/usr/include/c++/10/pstl/glue_memory_defs.h" 3 # 1 "/usr/include/c++/10/pstl/execution_defs.h" 1 3 # 15 "/usr/include/c++/10/pstl/execution_defs.h" 3 namespace __pstl { namespace execution { inline namespace v1 { class sequenced_policy { public: static constexpr std::false_type __allow_unsequenced() { return std::false_type{}; } static constexpr std::false_type __allow_vector() { return std::false_type{}; } static constexpr std::false_type __allow_parallel() { return std::false_type{}; } }; class parallel_policy { public: static constexpr std::false_type __allow_unsequenced() { return std::false_type{}; } static constexpr std::false_type __allow_vector() { return std::false_type{}; } static constexpr std::true_type __allow_parallel() { return std::true_type{}; } }; class parallel_unsequenced_policy { public: static constexpr std::true_type __allow_unsequenced() { return std::true_type{}; } static constexpr std::true_type __allow_vector() { return std::true_type{}; } static constexpr std::true_type __allow_parallel() { return std::true_type{}; } }; class unsequenced_policy { public: static constexpr std::true_type __allow_unsequenced() { return std::true_type{}; } static constexpr std::true_type __allow_vector() { return std::true_type{}; } static constexpr std::false_type __allow_parallel() { return std::false_type{}; } }; constexpr sequenced_policy seq{}; constexpr parallel_policy par{}; constexpr parallel_unsequenced_policy par_unseq{}; constexpr unsequenced_policy unseq{}; template struct is_execution_policy : std::false_type { }; template <> struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type { }; template <> struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type { }; template <> struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type { }; template <> struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type { }; template constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value; } } namespace __internal { template using __enable_if_execution_policy = typename std::enable_if<__pstl::execution::is_execution_policy>::value, _Tp>::type; } } # 14 "/usr/include/c++/10/pstl/glue_memory_defs.h" 2 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); } # 423 "/usr/include/c++/10/memory" 2 3 # 33 "all-std.cxx" 2 # 1 "/usr/include/c++/10/memory_resource" 1 3 # 32 "/usr/include/c++/10/memory_resource" 3 # 33 "/usr/include/c++/10/memory_resource" 3 # 1 "/usr/include/c++/10/shared_mutex" 1 3 # 32 "/usr/include/c++/10/shared_mutex" 3 # 33 "/usr/include/c++/10/shared_mutex" 3 # 1 "/usr/include/c++/10/condition_variable" 1 3 # 32 "/usr/include/c++/10/condition_variable" 3 # 33 "/usr/include/c++/10/condition_variable" 3 # 1 "/usr/include/c++/10/bits/std_mutex.h" 1 3 # 33 "/usr/include/c++/10/bits/std_mutex.h" 3 # 34 "/usr/include/c++/10/bits/std_mutex.h" 3 # 43 "/usr/include/c++/10/bits/std_mutex.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 57 "/usr/include/c++/10/bits/std_mutex.h" 3 class __mutex_base { protected: typedef __gthread_mutex_t __native_type; __native_type _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } }; constexpr __mutex_base() noexcept = default; # 78 "/usr/include/c++/10/bits/std_mutex.h" 3 __mutex_base(const __mutex_base&) = delete; __mutex_base& operator=(const __mutex_base&) = delete; }; class mutex : private __mutex_base { public: typedef __native_type* native_handle_type; constexpr mutex() noexcept = default; ~mutex() = default; mutex(const mutex&) = delete; mutex& operator=(const mutex&) = delete; void lock() { int __e = __gthread_mutex_lock(&_M_mutex); if (__e) __throw_system_error(__e); } bool try_lock() noexcept { return !__gthread_mutex_trylock(&_M_mutex); } void unlock() { __gthread_mutex_unlock(&_M_mutex); } native_handle_type native_handle() noexcept { return &_M_mutex; } }; struct defer_lock_t { explicit defer_lock_t() = default; }; struct try_to_lock_t { explicit try_to_lock_t() = default; }; struct adopt_lock_t { explicit adopt_lock_t() = default; }; inline constexpr defer_lock_t defer_lock { }; inline constexpr try_to_lock_t try_to_lock { }; inline constexpr adopt_lock_t adopt_lock { }; template class lock_guard { public: typedef _Mutex mutex_type; explicit lock_guard(mutex_type& __m) : _M_device(__m) { _M_device.lock(); } lock_guard(mutex_type& __m, adopt_lock_t) noexcept : _M_device(__m) { } ~lock_guard() { _M_device.unlock(); } lock_guard(const lock_guard&) = delete; lock_guard& operator=(const lock_guard&) = delete; private: mutex_type& _M_device; }; } # 41 "/usr/include/c++/10/condition_variable" 2 3 # 1 "/usr/include/c++/10/bits/unique_lock.h" 1 3 # 33 "/usr/include/c++/10/bits/unique_lock.h" 3 # 34 "/usr/include/c++/10/bits/unique_lock.h" 3 # 42 "/usr/include/c++/10/bits/unique_lock.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 55 "/usr/include/c++/10/bits/unique_lock.h" 3 template class unique_lock { public: typedef _Mutex mutex_type; unique_lock() noexcept : _M_device(0), _M_owns(false) { } explicit unique_lock(mutex_type& __m) : _M_device(std::__addressof(__m)), _M_owns(false) { lock(); _M_owns = true; } unique_lock(mutex_type& __m, defer_lock_t) noexcept : _M_device(std::__addressof(__m)), _M_owns(false) { } unique_lock(mutex_type& __m, try_to_lock_t) : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock()) { } unique_lock(mutex_type& __m, adopt_lock_t) noexcept : _M_device(std::__addressof(__m)), _M_owns(true) { } template unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __atime) : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock_until(__atime)) { } template unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __rtime) : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock_for(__rtime)) { } ~unique_lock() { if (_M_owns) unlock(); } unique_lock(const unique_lock&) = delete; unique_lock& operator=(const unique_lock&) = delete; unique_lock(unique_lock&& __u) noexcept : _M_device(__u._M_device), _M_owns(__u._M_owns) { __u._M_device = 0; __u._M_owns = false; } unique_lock& operator=(unique_lock&& __u) noexcept { if(_M_owns) unlock(); unique_lock(std::move(__u)).swap(*this); __u._M_device = 0; __u._M_owns = false; return *this; } void lock() { if (!_M_device) __throw_system_error(int(errc::operation_not_permitted)); else if (_M_owns) __throw_system_error(int(errc::resource_deadlock_would_occur)); else { _M_device->lock(); _M_owns = true; } } bool try_lock() { if (!_M_device) __throw_system_error(int(errc::operation_not_permitted)); else if (_M_owns) __throw_system_error(int(errc::resource_deadlock_would_occur)); else { _M_owns = _M_device->try_lock(); return _M_owns; } } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { if (!_M_device) __throw_system_error(int(errc::operation_not_permitted)); else if (_M_owns) __throw_system_error(int(errc::resource_deadlock_would_occur)); else { _M_owns = _M_device->try_lock_until(__atime); return _M_owns; } } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { if (!_M_device) __throw_system_error(int(errc::operation_not_permitted)); else if (_M_owns) __throw_system_error(int(errc::resource_deadlock_would_occur)); else { _M_owns = _M_device->try_lock_for(__rtime); return _M_owns; } } void unlock() { if (!_M_owns) __throw_system_error(int(errc::operation_not_permitted)); else if (_M_device) { _M_device->unlock(); _M_owns = false; } } void swap(unique_lock& __u) noexcept { std::swap(_M_device, __u._M_device); std::swap(_M_owns, __u._M_owns); } mutex_type* release() noexcept { mutex_type* __ret = _M_device; _M_device = 0; _M_owns = false; return __ret; } bool owns_lock() const noexcept { return _M_owns; } explicit operator bool() const noexcept { return owns_lock(); } mutex_type* mutex() const noexcept { return _M_device; } private: mutex_type* _M_device; bool _M_owns; }; template inline void swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept { __x.swap(__y); } } # 42 "/usr/include/c++/10/condition_variable" 2 3 # 50 "/usr/include/c++/10/condition_variable" 3 # 1 "/usr/include/c++/10/stop_token" 1 3 # 34 "/usr/include/c++/10/stop_token" 3 # 1 "/usr/include/c++/10/atomic" 1 3 # 35 "/usr/include/c++/10/atomic" 3 # 36 "/usr/include/c++/10/atomic" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 56 "/usr/include/c++/10/atomic" 3 template struct atomic; template<> struct atomic { using value_type = bool; private: __atomic_base _M_base; public: atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(bool __i) noexcept : _M_base(__i) { } bool operator=(bool __i) noexcept { return _M_base.operator=(__i); } bool operator=(bool __i) volatile noexcept { return _M_base.operator=(__i); } operator bool() const noexcept { return _M_base.load(); } operator bool() const volatile noexcept { return _M_base.load(); } bool is_lock_free() const noexcept { return _M_base.is_lock_free(); } bool is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } static constexpr bool is_always_lock_free = 2 == 2; void store(bool __i, memory_order __m = memory_order_seq_cst) noexcept { _M_base.store(__i, __m); } void store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { _M_base.store(__i, __m); } bool load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_base.load(__m); } bool load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_base.load(__m); } bool exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.exchange(__i, __m); } bool exchange(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.exchange(__i, __m); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } bool compare_exchange_weak(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_weak(__i1, __i2, __m); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } bool compare_exchange_strong(bool& __i1, bool __i2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_base.compare_exchange_strong(__i1, __i2, __m); } }; # 179 "/usr/include/c++/10/atomic" 3 template struct atomic { using value_type = _Tp; private: static constexpr int _S_min_alignment = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16 ? 0 : sizeof(_Tp); static constexpr int _S_alignment = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp); alignas(_S_alignment) _Tp _M_i = _Tp(); static_assert(__is_trivially_copyable(_Tp), "std::atomic requires a trivially copyable type"); static_assert(sizeof(_Tp) > 0, "Incomplete or zero-sized types are not supported"); static_assert(is_copy_constructible_v<_Tp>); static_assert(is_move_constructible_v<_Tp>); static_assert(is_copy_assignable_v<_Tp>); static_assert(is_move_assignable_v<_Tp>); public: atomic() = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(_Tp __i) noexcept : _M_i(__i) { } operator _Tp() const noexcept { return load(); } operator _Tp() const volatile noexcept { return load(); } _Tp operator=(_Tp __i) noexcept { store(__i); return __i; } _Tp operator=(_Tp __i) volatile noexcept { store(__i); return __i; } bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } bool is_lock_free() const volatile noexcept { return __atomic_is_lock_free(sizeof(_M_i), reinterpret_cast(-_S_alignment)); } static constexpr bool is_always_lock_free = __atomic_always_lock_free(sizeof(_M_i), 0); void store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); } void store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); } _Tp load(memory_order __m = memory_order_seq_cst) const noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); return *__ptr; } _Tp load(memory_order __m = memory_order_seq_cst) const volatile noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_load(std::__addressof(_M_i), __ptr, int(__m)); return *__ptr; } _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), __ptr, int(__m)); return *__ptr; } _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { alignas(_Tp) unsigned char __buf[sizeof(_Tp)]; _Tp* __ptr = reinterpret_cast<_Tp*>(__buf); __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), __ptr, int(__m)); return *__ptr; } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), std::__addressof(__e), std::__addressof(__i), true, int(__s), int(__f)); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), std::__addressof(__e), std::__addressof(__i), true, int(__s), int(__f)); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__e, __i, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__e, __i, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), std::__addressof(__e), std::__addressof(__i), false, int(__s), int(__f)); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), std::__addressof(__e), std::__addressof(__i), false, int(__s), int(__f)); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_strong(__e, __i, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_strong(__e, __i, __m, __cmpexch_failure_order(__m)); } }; template struct atomic<_Tp*> { using value_type = _Tp*; using difference_type = ptrdiff_t; typedef _Tp* __pointer_type; typedef __atomic_base<_Tp*> __base_type; __base_type _M_b; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { } operator __pointer_type() const noexcept { return __pointer_type(_M_b); } operator __pointer_type() const volatile noexcept { return __pointer_type(_M_b); } __pointer_type operator=(__pointer_type __p) noexcept { return _M_b.operator=(__p); } __pointer_type operator=(__pointer_type __p) volatile noexcept { return _M_b.operator=(__p); } __pointer_type operator++(int) noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b++; } __pointer_type operator++(int) volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b++; } __pointer_type operator--(int) noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b--; } __pointer_type operator--(int) volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b--; } __pointer_type operator++() noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return ++_M_b; } __pointer_type operator++() volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return ++_M_b; } __pointer_type operator--() noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return --_M_b; } __pointer_type operator--() volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return --_M_b; } __pointer_type operator+=(ptrdiff_t __d) noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.operator+=(__d); } __pointer_type operator+=(ptrdiff_t __d) volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.operator+=(__d); } __pointer_type operator-=(ptrdiff_t __d) noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.operator-=(__d); } __pointer_type operator-=(ptrdiff_t __d) volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.operator-=(__d); } bool is_lock_free() const noexcept { return _M_b.is_lock_free(); } bool is_lock_free() const volatile noexcept { return _M_b.is_lock_free(); } static constexpr bool is_always_lock_free = 2 == 2; void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.store(__p, __m); } void store(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.store(__p, __m); } __pointer_type load(memory_order __m = memory_order_seq_cst) const noexcept { return _M_b.load(__m); } __pointer_type load(memory_order __m = memory_order_seq_cst) const volatile noexcept { return _M_b.load(__m); } __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.exchange(__p, __m); } __pointer_type exchange(__pointer_type __p, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.exchange(__p, __m); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { return compare_exchange_weak(__p1, __p2, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { return compare_exchange_weak(__p1, __p2, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m1, memory_order __m2) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m, __cmpexch_failure_order(__m)); } bool compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, memory_order __m = memory_order_seq_cst) volatile noexcept { return _M_b.compare_exchange_strong(__p1, __p2, __m, __cmpexch_failure_order(__m)); } __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.fetch_add(__d, __m); } __pointer_type fetch_add(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.fetch_add(__d, __m); } __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.fetch_sub(__d, __m); } __pointer_type fetch_sub(ptrdiff_t __d, memory_order __m = memory_order_seq_cst) volatile noexcept { static_assert( is_object<_Tp>::value, "pointer to object type" ); return _M_b.fetch_sub(__d, __m); } }; template<> struct atomic : __atomic_base { typedef char __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef signed char __integral_type; typedef __atomic_base __base_type; atomic() noexcept= default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned char __integral_type; typedef __atomic_base __base_type; atomic() noexcept= default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef short __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned short __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef int __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned int __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef long long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef unsigned long long __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef wchar_t __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef char8_t __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef char16_t __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; template<> struct atomic : __atomic_base { typedef char32_t __integral_type; typedef __atomic_base __base_type; atomic() noexcept = default; ~atomic() noexcept = default; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } using __base_type::operator __integral_type; using __base_type::operator=; static constexpr bool is_always_lock_free = 2 == 2; }; typedef atomic atomic_bool; typedef atomic atomic_char; typedef atomic atomic_schar; typedef atomic atomic_uchar; typedef atomic atomic_short; typedef atomic atomic_ushort; typedef atomic atomic_int; typedef atomic atomic_uint; typedef atomic atomic_long; typedef atomic atomic_ulong; typedef atomic atomic_llong; typedef atomic atomic_ullong; typedef atomic atomic_wchar_t; typedef atomic atomic_char8_t; typedef atomic atomic_char16_t; typedef atomic atomic_char32_t; typedef atomic atomic_int8_t; typedef atomic atomic_uint8_t; typedef atomic atomic_int16_t; typedef atomic atomic_uint16_t; typedef atomic atomic_int32_t; typedef atomic atomic_uint32_t; typedef atomic atomic_int64_t; typedef atomic atomic_uint64_t; typedef atomic atomic_int_least8_t; typedef atomic atomic_uint_least8_t; typedef atomic atomic_int_least16_t; typedef atomic atomic_uint_least16_t; typedef atomic atomic_int_least32_t; typedef atomic atomic_uint_least32_t; typedef atomic atomic_int_least64_t; typedef atomic atomic_uint_least64_t; typedef atomic atomic_int_fast8_t; typedef atomic atomic_uint_fast8_t; typedef atomic atomic_int_fast16_t; typedef atomic atomic_uint_fast16_t; typedef atomic atomic_int_fast32_t; typedef atomic atomic_uint_fast32_t; typedef atomic atomic_int_fast64_t; typedef atomic atomic_uint_fast64_t; typedef atomic atomic_intptr_t; typedef atomic atomic_uintptr_t; typedef atomic atomic_size_t; typedef atomic atomic_ptrdiff_t; typedef atomic atomic_intmax_t; typedef atomic atomic_uintmax_t; inline bool atomic_flag_test_and_set_explicit(atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { return __a->test_and_set(__m); } inline void atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } inline void atomic_flag_clear_explicit(volatile atomic_flag* __a, memory_order __m) noexcept { __a->clear(__m); } inline bool atomic_flag_test_and_set(atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } inline bool atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } inline void atomic_flag_clear(atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } inline void atomic_flag_clear(volatile atomic_flag* __a) noexcept { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } template using __atomic_val_t = typename atomic<_Tp>::value_type; template using __atomic_diff_t = typename atomic<_Tp>::difference_type; template inline bool atomic_is_lock_free(const atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template inline bool atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept { return __a->is_lock_free(); } template inline void atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { __a->store(__i, memory_order_relaxed); } template inline void atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { __a->store(__i, memory_order_relaxed); } template inline void atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { __a->store(__i, __m); } template inline void atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { __a->store(__i, __m); } template inline _ITp atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template inline _ITp atomic_load_explicit(const volatile atomic<_ITp>* __a, memory_order __m) noexcept { return __a->load(__m); } template inline _ITp atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template inline _ITp atomic_exchange_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->exchange(__i, __m); } template inline bool atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template inline bool atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } template inline bool atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template inline bool atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2, memory_order __m1, memory_order __m2) noexcept { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } template inline void atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template inline void atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { atomic_store_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_load(const atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template inline _ITp atomic_load(const volatile atomic<_ITp>* __a) noexcept { return atomic_load_explicit(__a, memory_order_seq_cst); } template inline _ITp atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_exchange(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_strong(atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } template inline bool atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp>* __i1, __atomic_val_t<_ITp> __i2) noexcept { return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, memory_order_seq_cst, memory_order_seq_cst); } template inline _ITp atomic_fetch_add_explicit(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template inline _ITp atomic_fetch_add_explicit(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_add(__i, __m); } template inline _ITp atomic_fetch_sub_explicit(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template inline _ITp atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_sub(__i, __m); } template inline _ITp atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template inline _ITp atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_and(__i, __m); } template inline _ITp atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template inline _ITp atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_or(__i, __m); } template inline _ITp atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template inline _ITp atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i, memory_order __m) noexcept { return __a->fetch_xor(__i, __m); } template inline _ITp atomic_fetch_add(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_add(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_sub(atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_sub(volatile atomic<_ITp>* __a, __atomic_diff_t<_ITp> __i) noexcept { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_and(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_and(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_or(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_or(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_xor(__atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } template inline _ITp atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } template<> struct atomic : __atomic_float { atomic() noexcept = default; constexpr atomic(float __fp) noexcept : __atomic_float(__fp) { } atomic& operator=(const atomic&) volatile = delete; atomic& operator=(const atomic&) = delete; using __atomic_float::operator=; }; template<> struct atomic : __atomic_float { atomic() noexcept = default; constexpr atomic(double __fp) noexcept : __atomic_float(__fp) { } atomic& operator=(const atomic&) volatile = delete; atomic& operator=(const atomic&) = delete; using __atomic_float::operator=; }; template<> struct atomic : __atomic_float { atomic() noexcept = default; constexpr atomic(long double __fp) noexcept : __atomic_float(__fp) { } atomic& operator=(const atomic&) volatile = delete; atomic& operator=(const atomic&) = delete; using __atomic_float::operator=; }; template struct atomic_ref : __atomic_ref<_Tp> { explicit atomic_ref(_Tp& __t) noexcept : __atomic_ref<_Tp>(__t) { } atomic_ref& operator=(const atomic_ref&) = delete; atomic_ref(const atomic_ref&) = default; using __atomic_ref<_Tp>::operator=; }; } # 35 "/usr/include/c++/10/stop_token" 2 3 # 44 "/usr/include/c++/10/stop_token" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct nostopstate_t { explicit nostopstate_t() = default; }; inline constexpr nostopstate_t nostopstate{}; class stop_source; class stop_token { public: stop_token() noexcept = default; stop_token(const stop_token&) noexcept = default; stop_token(stop_token&&) noexcept = default; ~stop_token() = default; stop_token& operator=(const stop_token&) noexcept = default; stop_token& operator=(stop_token&&) noexcept = default; [[nodiscard]] bool stop_possible() const noexcept { return static_cast(_M_state) && _M_state->_M_stop_possible(); } [[nodiscard]] bool stop_requested() const noexcept { return static_cast(_M_state) && _M_state->_M_stop_requested(); } void swap(stop_token& __rhs) noexcept { _M_state.swap(__rhs._M_state); } [[nodiscard]] friend bool operator==(const stop_token& __a, const stop_token& __b) { return __a._M_state == __b._M_state; } friend void swap(stop_token& __lhs, stop_token& __rhs) noexcept { __lhs.swap(__rhs); } private: friend class stop_source; template friend class stop_callback; static void _S_yield() noexcept { __builtin_ia32_pause(); } struct binary_semaphore { explicit binary_semaphore(int __d) : _M_counter(__d > 0) { } void release() { _M_counter.fetch_add(1, memory_order::release); } void acquire() { int __old = 1; while (!_M_counter.compare_exchange_weak(__old, 0, memory_order::acquire, memory_order::relaxed)) { __old = 1; _S_yield(); } } atomic _M_counter; }; struct _Stop_cb { using __cb_type = void(_Stop_cb*) noexcept; __cb_type* _M_callback; _Stop_cb* _M_prev = nullptr; _Stop_cb* _M_next = nullptr; bool* _M_destroyed = nullptr; binary_semaphore _M_done{0}; [[__gnu__::__nonnull__]] explicit _Stop_cb(__cb_type* __cb) : _M_callback(__cb) { } void _M_run() noexcept { _M_callback(this); } }; struct _Stop_state_t { using value_type = uint32_t; static constexpr value_type _S_stop_requested_bit = 1; static constexpr value_type _S_locked_bit = 2; static constexpr value_type _S_ssrc_counter_inc = 4; std::atomic _M_owners{1}; std::atomic _M_value{_S_ssrc_counter_inc}; _Stop_cb* _M_head = nullptr; __gthread_t _M_requester; _Stop_state_t() noexcept { } bool _M_stop_possible() noexcept { return _M_value.load(memory_order::acquire) & ~_S_locked_bit; } bool _M_stop_requested() noexcept { return _M_value.load(memory_order::acquire) & _S_stop_requested_bit; } void _M_add_owner() noexcept { _M_owners.fetch_add(1, memory_order::relaxed); } void _M_release_ownership() noexcept { if (_M_owners.fetch_sub(1, memory_order::acq_rel) == 1) delete this; } void _M_add_ssrc() noexcept { _M_value.fetch_add(_S_ssrc_counter_inc, memory_order::relaxed); } void _M_sub_ssrc() noexcept { _M_value.fetch_sub(_S_ssrc_counter_inc, memory_order::release); } void _M_lock() noexcept { auto __old = _M_value.load(memory_order::relaxed); while (!_M_try_lock(__old, memory_order::relaxed)) { } } void _M_unlock() noexcept { _M_value.fetch_sub(_S_locked_bit, memory_order::release); } bool _M_request_stop() noexcept { auto __old = _M_value.load(memory_order::acquire); do { if (__old & _S_stop_requested_bit) return false; } while (!_M_try_lock_and_stop(__old)); _M_requester = pthread_self(); while (_M_head) { bool __last_cb; _Stop_cb* __cb = _M_head; _M_head = _M_head->_M_next; if (_M_head) { _M_head->_M_prev = nullptr; __last_cb = false; } else __last_cb = true; _M_unlock(); bool __destroyed = false; __cb->_M_destroyed = &__destroyed; __cb->_M_run(); if (!__destroyed) { __cb->_M_destroyed = nullptr; __cb->_M_done.release(); } if (__last_cb) return true; _M_lock(); } _M_unlock(); return true; } [[__gnu__::__nonnull__]] bool _M_register_callback(_Stop_cb* __cb) noexcept { auto __old = _M_value.load(memory_order::acquire); do { if (__old & _S_stop_requested_bit) { __cb->_M_run(); return false; } if (__old < _S_ssrc_counter_inc) return false; } while (!_M_try_lock(__old)); __cb->_M_next = _M_head; if (_M_head) { _M_head->_M_prev = __cb; } _M_head = __cb; _M_unlock(); return true; } [[__gnu__::__nonnull__]] void _M_remove_callback(_Stop_cb* __cb) { _M_lock(); if (__cb == _M_head) { _M_head = _M_head->_M_next; if (_M_head) _M_head->_M_prev = nullptr; _M_unlock(); return; } else if (__cb->_M_prev) { __cb->_M_prev->_M_next = __cb->_M_next; if (__cb->_M_next) __cb->_M_next->_M_prev = __cb->_M_prev; _M_unlock(); return; } _M_unlock(); auto __tid = pthread_self(); if (!__gthread_equal(_M_requester, __tid)) { __cb->_M_done.acquire(); return; } if (__cb->_M_destroyed) *__cb->_M_destroyed = true; } bool _M_try_lock(value_type& __curval, memory_order __failure = memory_order::acquire) noexcept { return _M_do_try_lock(__curval, 0, memory_order::acquire, __failure); } bool _M_try_lock_and_stop(value_type& __curval) noexcept { return _M_do_try_lock(__curval, _S_stop_requested_bit, memory_order::acq_rel, memory_order::acquire); } bool _M_do_try_lock(value_type& __curval, value_type __newbits, memory_order __success, memory_order __failure) noexcept { if (__curval & _S_locked_bit) { _S_yield(); __curval = _M_value.load(__failure); return false; } __newbits |= _S_locked_bit; return _M_value.compare_exchange_weak(__curval, __curval | __newbits, __success, __failure); } }; struct _Stop_state_ref { _Stop_state_ref() = default; explicit _Stop_state_ref(const stop_source&) : _M_ptr(new _Stop_state_t()) { } _Stop_state_ref(const _Stop_state_ref& __other) noexcept : _M_ptr(__other._M_ptr) { if (_M_ptr) _M_ptr->_M_add_owner(); } _Stop_state_ref(_Stop_state_ref&& __other) noexcept : _M_ptr(__other._M_ptr) { __other._M_ptr = nullptr; } _Stop_state_ref& operator=(const _Stop_state_ref& __other) noexcept { if (auto __ptr = __other._M_ptr; __ptr != _M_ptr) { if (__ptr) __ptr->_M_add_owner(); if (_M_ptr) _M_ptr->_M_release_ownership(); _M_ptr = __ptr; } return *this; } _Stop_state_ref& operator=(_Stop_state_ref&& __other) noexcept { _Stop_state_ref(std::move(__other)).swap(*this); return *this; } ~_Stop_state_ref() { if (_M_ptr) _M_ptr->_M_release_ownership(); } void swap(_Stop_state_ref& __other) noexcept { std::swap(_M_ptr, __other._M_ptr); } explicit operator bool() const noexcept { return _M_ptr != nullptr; } _Stop_state_t* operator->() const noexcept { return _M_ptr; } friend bool operator==(const _Stop_state_ref&, const _Stop_state_ref&) = default; # 483 "/usr/include/c++/10/stop_token" 3 private: _Stop_state_t* _M_ptr = nullptr; }; _Stop_state_ref _M_state; explicit stop_token(const _Stop_state_ref& __state) noexcept : _M_state{__state} { } }; class stop_source { public: stop_source() : _M_state(*this) { } explicit stop_source(std::nostopstate_t) noexcept { } stop_source(const stop_source& __other) noexcept : _M_state(__other._M_state) { if (_M_state) _M_state->_M_add_ssrc(); } stop_source(stop_source&&) noexcept = default; stop_source& operator=(const stop_source& __other) noexcept { if (_M_state != __other._M_state) { stop_source __sink(std::move(*this)); _M_state = __other._M_state; if (_M_state) _M_state->_M_add_ssrc(); } return *this; } stop_source& operator=(stop_source&&) noexcept = default; ~stop_source() { if (_M_state) _M_state->_M_sub_ssrc(); } [[nodiscard]] bool stop_possible() const noexcept { return static_cast(_M_state); } [[nodiscard]] bool stop_requested() const noexcept { return static_cast(_M_state) && _M_state->_M_stop_requested(); } bool request_stop() const noexcept { if (stop_possible()) return _M_state->_M_request_stop(); return false; } [[nodiscard]] stop_token get_token() const noexcept { return stop_token{_M_state}; } void swap(stop_source& __other) noexcept { _M_state.swap(__other._M_state); } [[nodiscard]] friend bool operator==(const stop_source& __a, const stop_source& __b) noexcept { return __a._M_state == __b._M_state; } friend void swap(stop_source& __lhs, stop_source& __rhs) noexcept { __lhs.swap(__rhs); } private: stop_token::_Stop_state_ref _M_state; }; template class [[nodiscard]] stop_callback { static_assert(is_nothrow_destructible_v<_Callback>); static_assert(is_invocable_v<_Callback>); public: using callback_type = _Callback; template, int> = 0> explicit stop_callback(const stop_token& __token, _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>) : _M_cb(std::forward<_Cb>(__cb)) { if (auto __state = __token._M_state) { if (__state->_M_register_callback(&_M_cb)) _M_state.swap(__state); } } template, int> = 0> explicit stop_callback(stop_token&& __token, _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>) : _M_cb(std::forward<_Cb>(__cb)) { if (auto& __state = __token._M_state) { if (__state->_M_register_callback(&_M_cb)) _M_state.swap(__state); } } ~stop_callback() { if (_M_state) { _M_state->_M_remove_callback(&_M_cb); } } stop_callback(const stop_callback&) = delete; stop_callback& operator=(const stop_callback&) = delete; stop_callback(stop_callback&&) = delete; stop_callback& operator=(stop_callback&&) = delete; private: struct _Cb_impl : stop_token::_Stop_cb { template explicit _Cb_impl(_Cb&& __cb) : _Stop_cb(&_S_execute), _M_cb(std::forward<_Cb>(__cb)) { } _Callback _M_cb; [[__gnu__::__nonnull__]] static void _S_execute(_Stop_cb* __that) noexcept { _Callback& __cb = static_cast<_Cb_impl*>(__that)->_M_cb; std::forward<_Callback>(__cb)(); } }; _Cb_impl _M_cb; stop_token::_Stop_state_ref _M_state; }; template stop_callback(stop_token, _Callback) -> stop_callback<_Callback>; } # 51 "/usr/include/c++/10/condition_variable" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 68 "/usr/include/c++/10/condition_variable" 3 enum class cv_status { no_timeout, timeout }; class condition_variable { using steady_clock = chrono::steady_clock; using system_clock = chrono::system_clock; using __clock_t = steady_clock; typedef __gthread_cond_t __native_type; __native_type _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }; public: typedef __native_type* native_handle_type; condition_variable() noexcept; ~condition_variable() noexcept; condition_variable(const condition_variable&) = delete; condition_variable& operator=(const condition_variable&) = delete; void notify_one() noexcept; void notify_all() noexcept; void wait(unique_lock& __lock) noexcept; template void wait(unique_lock& __lock, _Predicate __p) { while (!__p()) wait(__lock); } template cv_status wait_until(unique_lock& __lock, const chrono::time_point& __atime) { return __wait_until_impl(__lock, __atime); } template cv_status wait_until(unique_lock& __lock, const chrono::time_point& __atime) { return __wait_until_impl(__lock, __atime); } template cv_status wait_until(unique_lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime) { static_assert(chrono::is_clock_v<_Clock>); const typename _Clock::time_point __c_entry = _Clock::now(); const __clock_t::time_point __s_entry = __clock_t::now(); const auto __delta = __atime - __c_entry; const auto __s_atime = __s_entry + __delta; if (__wait_until_impl(__lock, __s_atime) == cv_status::no_timeout) return cv_status::no_timeout; if (_Clock::now() < __atime) return cv_status::no_timeout; return cv_status::timeout; } template bool wait_until(unique_lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime, _Predicate __p) { while (!__p()) if (wait_until(__lock, __atime) == cv_status::timeout) return __p(); return true; } template cv_status wait_for(unique_lock& __lock, const chrono::duration<_Rep, _Period>& __rtime) { using __dur = typename steady_clock::duration; auto __reltime = chrono::duration_cast<__dur>(__rtime); if (__reltime < __rtime) ++__reltime; return wait_until(__lock, steady_clock::now() + __reltime); } template bool wait_for(unique_lock& __lock, const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) { using __dur = typename steady_clock::duration; auto __reltime = chrono::duration_cast<__dur>(__rtime); if (__reltime < __rtime) ++__reltime; return wait_until(__lock, steady_clock::now() + __reltime, std::move(__p)); } native_handle_type native_handle() { return &_M_cond; } private: template cv_status __wait_until_impl(unique_lock& __lock, const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; pthread_cond_clockwait(&_M_cond, __lock.mutex()->native_handle(), 1, &__ts); return (steady_clock::now() < __atime ? cv_status::no_timeout : cv_status::timeout); } template cv_status __wait_until_impl(unique_lock& __lock, const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; __gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(), &__ts); return (system_clock::now() < __atime ? cv_status::no_timeout : cv_status::timeout); } }; void notify_all_at_thread_exit(condition_variable&, unique_lock); struct __at_thread_exit_elt { __at_thread_exit_elt* _M_next; void (*_M_cb)(void*); }; inline namespace _V2 { class condition_variable_any { using __clock_t = chrono::steady_clock; condition_variable _M_cond; shared_ptr _M_mutex; template struct _Unlock { explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" ~_Unlock() noexcept(false) { if (uncaught_exception()) { try { _M_lock.lock(); } catch(const __cxxabiv1::__forced_unwind&) { throw; } catch(...) { } } else _M_lock.lock(); } #pragma GCC diagnostic pop _Unlock(const _Unlock&) = delete; _Unlock& operator=(const _Unlock&) = delete; _Lock& _M_lock; }; public: condition_variable_any() : _M_mutex(std::make_shared()) { } ~condition_variable_any() = default; condition_variable_any(const condition_variable_any&) = delete; condition_variable_any& operator=(const condition_variable_any&) = delete; void notify_one() noexcept { lock_guard __lock(*_M_mutex); _M_cond.notify_one(); } void notify_all() noexcept { lock_guard __lock(*_M_mutex); _M_cond.notify_all(); } template void wait(_Lock& __lock) { shared_ptr __mutex = _M_mutex; unique_lock __my_lock(*__mutex); _Unlock<_Lock> __unlock(__lock); unique_lock __my_lock2(std::move(__my_lock)); _M_cond.wait(__my_lock2); } template void wait(_Lock& __lock, _Predicate __p) { while (!__p()) wait(__lock); } template cv_status wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime) { shared_ptr __mutex = _M_mutex; unique_lock __my_lock(*__mutex); _Unlock<_Lock> __unlock(__lock); unique_lock __my_lock2(std::move(__my_lock)); return _M_cond.wait_until(__my_lock2, __atime); } template bool wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __atime, _Predicate __p) { while (!__p()) if (wait_until(__lock, __atime) == cv_status::timeout) return __p(); return true; } template cv_status wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime) { return wait_until(__lock, __clock_t::now() + __rtime); } template bool wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } template bool wait(_Lock& __lock, stop_token __stoken, _Predicate __p) { if (__stoken.stop_requested()) { return __p(); } std::stop_callback __cb(__stoken, [this] { notify_all(); }); shared_ptr __mutex = _M_mutex; while (!__p()) { unique_lock __my_lock(*__mutex); if (__stoken.stop_requested()) { return false; } _Unlock<_Lock> __unlock(__lock); unique_lock __my_lock2(std::move(__my_lock)); _M_cond.wait(__my_lock2); } return true; } template bool wait_until(_Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __p) { if (__stoken.stop_requested()) { return __p(); } std::stop_callback __cb(__stoken, [this] { notify_all(); }); shared_ptr __mutex = _M_mutex; while (!__p()) { bool __stop; { unique_lock __my_lock(*__mutex); if (__stoken.stop_requested()) { return false; } _Unlock<_Lock> __u(__lock); unique_lock __my_lock2(std::move(__my_lock)); const auto __status = _M_cond.wait_until(__my_lock2, __abs_time); __stop = (__status == std::cv_status::timeout) || __stoken.stop_requested(); } if (__stop) { return __p(); } } return true; } template bool wait_for(_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __p) { auto __abst = std::chrono::steady_clock::now() + __rel_time; return wait_until(__lock, std::move(__stoken), __abst, std::move(__p)); } }; } } # 38 "/usr/include/c++/10/shared_mutex" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 53 "/usr/include/c++/10/shared_mutex" 3 class shared_mutex; class shared_timed_mutex; # 73 "/usr/include/c++/10/shared_mutex" 3 static __typeof(pthread_rwlock_rdlock) __gthrw_pthread_rwlock_rdlock __attribute__ ((__weakref__("pthread_rwlock_rdlock"), __copy__ (pthread_rwlock_rdlock))); ; static inline int __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_rdlock (__rwlock); else return 0; } static __typeof(pthread_rwlock_tryrdlock) __gthrw_pthread_rwlock_tryrdlock __attribute__ ((__weakref__("pthread_rwlock_tryrdlock"), __copy__ (pthread_rwlock_tryrdlock))); ; static inline int __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_tryrdlock (__rwlock); else return 0; } static __typeof(pthread_rwlock_wrlock) __gthrw_pthread_rwlock_wrlock __attribute__ ((__weakref__("pthread_rwlock_wrlock"), __copy__ (pthread_rwlock_wrlock))); ; static inline int __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_wrlock (__rwlock); else return 0; } static __typeof(pthread_rwlock_trywrlock) __gthrw_pthread_rwlock_trywrlock __attribute__ ((__weakref__("pthread_rwlock_trywrlock"), __copy__ (pthread_rwlock_trywrlock))); ; static inline int __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_trywrlock (__rwlock); else return 0; } static __typeof(pthread_rwlock_unlock) __gthrw_pthread_rwlock_unlock __attribute__ ((__weakref__("pthread_rwlock_unlock"), __copy__ (pthread_rwlock_unlock))); ; static inline int __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_unlock (__rwlock); else return 0; } # 91 "/usr/include/c++/10/shared_mutex" 3 static __typeof(pthread_rwlock_timedrdlock) __gthrw_pthread_rwlock_timedrdlock __attribute__ ((__weakref__("pthread_rwlock_timedrdlock"), __copy__ (pthread_rwlock_timedrdlock))); ; static inline int __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock, const timespec *__ts) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_timedrdlock (__rwlock, __ts); else return 0; } static __typeof(pthread_rwlock_timedwrlock) __gthrw_pthread_rwlock_timedwrlock __attribute__ ((__weakref__("pthread_rwlock_timedwrlock"), __copy__ (pthread_rwlock_timedwrlock))); ; static inline int __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock, const timespec *__ts) { if (__gthread_active_p ()) return __gthrw_pthread_rwlock_timedwrlock (__rwlock, __ts); else return 0; } # 147 "/usr/include/c++/10/shared_mutex" 3 class __shared_mutex_pthread { friend class shared_timed_mutex; pthread_rwlock_t _M_rwlock = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0 }, 0, PTHREAD_RWLOCK_DEFAULT_NP } }; public: __shared_mutex_pthread() = default; ~__shared_mutex_pthread() = default; # 182 "/usr/include/c++/10/shared_mutex" 3 __shared_mutex_pthread(const __shared_mutex_pthread&) = delete; __shared_mutex_pthread& operator=(const __shared_mutex_pthread&) = delete; void lock() { int __ret = __glibcxx_rwlock_wrlock(&_M_rwlock); if (__ret == 35) __throw_system_error(int(errc::resource_deadlock_would_occur)); ; } bool try_lock() { int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock); if (__ret == 16) return false; ; return true; } void unlock() { int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock); ; } void lock_shared() { int __ret; do __ret = __glibcxx_rwlock_rdlock(&_M_rwlock); while (__ret == 11); if (__ret == 35) __throw_system_error(int(errc::resource_deadlock_would_occur)); ; } bool try_lock_shared() { int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock); if (__ret == 16 || __ret == 11) return false; ; return true; } void unlock_shared() { unlock(); } void* native_handle() { return &_M_rwlock; } }; # 404 "/usr/include/c++/10/shared_mutex" 3 class shared_mutex { public: shared_mutex() = default; ~shared_mutex() = default; shared_mutex(const shared_mutex&) = delete; shared_mutex& operator=(const shared_mutex&) = delete; void lock() { _M_impl.lock(); } bool try_lock() { return _M_impl.try_lock(); } void unlock() { _M_impl.unlock(); } void lock_shared() { _M_impl.lock_shared(); } bool try_lock_shared() { return _M_impl.try_lock_shared(); } void unlock_shared() { _M_impl.unlock_shared(); } typedef void* native_handle_type; native_handle_type native_handle() { return _M_impl.native_handle(); } private: __shared_mutex_pthread _M_impl; }; using __shared_timed_mutex_base = __shared_mutex_pthread; class shared_timed_mutex : private __shared_timed_mutex_base { using _Base = __shared_timed_mutex_base; using __clock_t = chrono::steady_clock; public: shared_timed_mutex() = default; ~shared_timed_mutex() = default; shared_timed_mutex(const shared_timed_mutex&) = delete; shared_timed_mutex& operator=(const shared_timed_mutex&) = delete; void lock() { _Base::lock(); } bool try_lock() { return _Base::try_lock(); } void unlock() { _Base::unlock(); } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime); if (ratio_greater<__clock_t::period, _Period>()) ++__rt; return try_lock_until(__clock_t::now() + __rt); } void lock_shared() { _Base::lock_shared(); } bool try_lock_shared() { return _Base::try_lock_shared(); } void unlock_shared() { _Base::unlock_shared(); } template bool try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rtime) { auto __rt = chrono::duration_cast<__clock_t::duration>(__rtime); if (ratio_greater<__clock_t::period, _Period>()) ++__rt; return try_lock_shared_until(__clock_t::now() + __rt); } template bool try_lock_until(const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; int __ret = __glibcxx_rwlock_timedwrlock(&_M_rwlock, &__ts); if (__ret == 110 || __ret == 35) return false; ; return true; } template bool try_lock_until(const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; int __ret = pthread_rwlock_clockwrlock(&_M_rwlock, 1, &__ts); if (__ret == 110 || __ret == 35) return false; ; return true; } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { static_assert(chrono::is_clock_v<_Clock>); typename _Clock::time_point __now = _Clock::now(); do { auto __rtime = __atime - __now; if (try_lock_for(__rtime)) return true; __now = _Clock::now(); } while (__atime > __now); return false; } template bool try_lock_shared_until(const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; int __ret; # 603 "/usr/include/c++/10/shared_mutex" 3 do __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts); while (__ret == 11 || __ret == 35); if (__ret == 110) return false; ; return true; } template bool try_lock_shared_until(const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; int __ret = pthread_rwlock_clockrdlock(&_M_rwlock, 1, &__ts); if (__ret == 110 || __ret == 35) return false; ; return true; } template bool try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __atime) { static_assert(chrono::is_clock_v<_Clock>); typename _Clock::time_point __now = _Clock::now(); do { auto __rtime = __atime - __now; if (try_lock_shared_for(__rtime)) return true; __now = _Clock::now(); } while (__atime > __now); return false; } # 705 "/usr/include/c++/10/shared_mutex" 3 }; template class shared_lock { public: typedef _Mutex mutex_type; shared_lock() noexcept : _M_pm(nullptr), _M_owns(false) { } explicit shared_lock(mutex_type& __m) : _M_pm(std::__addressof(__m)), _M_owns(true) { __m.lock_shared(); } shared_lock(mutex_type& __m, defer_lock_t) noexcept : _M_pm(std::__addressof(__m)), _M_owns(false) { } shared_lock(mutex_type& __m, try_to_lock_t) : _M_pm(std::__addressof(__m)), _M_owns(__m.try_lock_shared()) { } shared_lock(mutex_type& __m, adopt_lock_t) : _M_pm(std::__addressof(__m)), _M_owns(true) { } template shared_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __abs_time) : _M_pm(std::__addressof(__m)), _M_owns(__m.try_lock_shared_until(__abs_time)) { } template shared_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __rel_time) : _M_pm(std::__addressof(__m)), _M_owns(__m.try_lock_shared_for(__rel_time)) { } ~shared_lock() { if (_M_owns) _M_pm->unlock_shared(); } shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete; shared_lock(shared_lock&& __sl) noexcept : shared_lock() { swap(__sl); } shared_lock& operator=(shared_lock&& __sl) noexcept { shared_lock(std::move(__sl)).swap(*this); return *this; } void lock() { _M_lockable(); _M_pm->lock_shared(); _M_owns = true; } bool try_lock() { _M_lockable(); return _M_owns = _M_pm->try_lock_shared(); } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time) { _M_lockable(); return _M_owns = _M_pm->try_lock_shared_for(__rel_time); } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time) { _M_lockable(); return _M_owns = _M_pm->try_lock_shared_until(__abs_time); } void unlock() { if (!_M_owns) __throw_system_error(int(errc::resource_deadlock_would_occur)); _M_pm->unlock_shared(); _M_owns = false; } void swap(shared_lock& __u) noexcept { std::swap(_M_pm, __u._M_pm); std::swap(_M_owns, __u._M_owns); } mutex_type* release() noexcept { _M_owns = false; return std::exchange(_M_pm, nullptr); } bool owns_lock() const noexcept { return _M_owns; } explicit operator bool() const noexcept { return _M_owns; } mutex_type* mutex() const noexcept { return _M_pm; } private: void _M_lockable() const { if (_M_pm == nullptr) __throw_system_error(int(errc::operation_not_permitted)); if (_M_owns) __throw_system_error(int(errc::resource_deadlock_would_occur)); } mutex_type* _M_pm; bool _M_owns; }; template void swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept { __x.swap(__y); } } # 41 "/usr/include/c++/10/memory_resource" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { # 58 "/usr/include/c++/10/memory_resource" 3 class memory_resource; template class polymorphic_allocator; memory_resource* new_delete_resource() noexcept; memory_resource* null_memory_resource() noexcept; memory_resource* set_default_resource(memory_resource* __r) noexcept; memory_resource* get_default_resource() noexcept __attribute__((__returns_nonnull__)); struct pool_options; class synchronized_pool_resource; class unsynchronized_pool_resource; class monotonic_buffer_resource; 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 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); } 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; }; inline bool operator==(const memory_resource& __a, const memory_resource& __b) noexcept { return &__a == &__b || __a.is_equal(__b); } # 133 "/usr/include/c++/10/memory_resource" 3 template class polymorphic_allocator { template struct __not_pair { using type = void; }; template struct __not_pair> { }; public: using value_type = _Tp; polymorphic_allocator() noexcept : _M_resource(get_default_resource()) { } polymorphic_allocator(memory_resource* __r) noexcept __attribute__((__nonnull__)) : _M_resource(__r) { ; } polymorphic_allocator(const polymorphic_allocator& __other) = default; template 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 (__n > (__gnu_cxx::__int_traits::__max / sizeof(_Tp))) (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 [[nodiscard]] _Up* allocate_object(size_t __n = 1) { if ((__gnu_cxx::__int_traits::__max / sizeof(_Up)) < __n) (throw (bad_array_new_length())); return static_cast<_Up*>(allocate_bytes(__n * sizeof(_Up), alignof(_Up))); } template void deallocate_object(_Up* __p, size_t __n = 1) { deallocate_bytes(__p, __n * sizeof(_Up), alignof(_Up)); } template [[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 void delete_object(_Up* __p) { destroy(__p); deallocate_object(__p); } # 308 "/usr/include/c++/10/memory_resource" 3 template __attribute__((__nonnull__)) void construct(_Tp1* __p, _Args&&... __args) { std::uninitialized_construct_using_allocator(__p, *this, std::forward<_Args>(__args)...); } template __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; } private: using __uses_alloc1_ = __uses_alloc1; using __uses_alloc2_ = __uses_alloc2; template static tuple<_Args&&...> _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) { return std::move(__t); } template static tuple _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, tuple<_Args...>& __t) { return { allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... }; } template static tuple<_Args&&..., polymorphic_allocator> _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, tuple<_Args...>& __t) { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } memory_resource* _M_resource; }; template inline bool operator==(const polymorphic_allocator<_Tp1>& __a, const polymorphic_allocator<_Tp2>& __b) noexcept { return *__a.resource() == *__b.resource(); } # 376 "/usr/include/c++/10/memory_resource" 3 struct pool_options { size_t max_blocks_per_chunk = 0; size_t largest_required_pool_block = 0; }; class __pool_resource { friend class synchronized_pool_resource; friend class unsynchronized_pool_resource; __pool_resource(const pool_options& __opts, memory_resource* __upstream); ~__pool_resource(); __pool_resource(const __pool_resource&) = delete; __pool_resource& operator=(const __pool_resource&) = delete; void* allocate(size_t __bytes, size_t __alignment); void deallocate(void* __p, size_t __bytes, size_t __alignment); void release() noexcept; memory_resource* resource() const noexcept { return _M_unpooled.get_allocator().resource(); } struct _Pool; _Pool* _M_alloc_pools(); const pool_options _M_opts; struct _BigBlock; std::pmr::vector<_BigBlock> _M_unpooled; const int _M_npools; }; class synchronized_pool_resource : public memory_resource { public: synchronized_pool_resource(const pool_options& __opts, memory_resource* __upstream) __attribute__((__nonnull__)); synchronized_pool_resource() : synchronized_pool_resource(pool_options(), get_default_resource()) { } explicit synchronized_pool_resource(memory_resource* __upstream) __attribute__((__nonnull__)) : synchronized_pool_resource(pool_options(), __upstream) { } explicit synchronized_pool_resource(const pool_options& __opts) : synchronized_pool_resource(__opts, get_default_resource()) { } synchronized_pool_resource(const synchronized_pool_resource&) = delete; virtual ~synchronized_pool_resource(); synchronized_pool_resource& operator=(const synchronized_pool_resource&) = delete; void release(); memory_resource* upstream_resource() const noexcept __attribute__((__returns_nonnull__)) { return _M_impl.resource(); } pool_options options() const noexcept { return _M_impl._M_opts; } protected: void* do_allocate(size_t __bytes, size_t __alignment) override; void do_deallocate(void* __p, size_t __bytes, size_t __alignment) override; bool do_is_equal(const memory_resource& __other) const noexcept override { return this == &__other; } public: struct _TPools; private: _TPools* _M_alloc_tpools(lock_guard&); _TPools* _M_alloc_shared_tpools(lock_guard&); auto _M_thread_specific_pools() noexcept; __pool_resource _M_impl; __gthread_key_t _M_key; _TPools* _M_tpools = nullptr; mutable shared_mutex _M_mx; }; class unsynchronized_pool_resource : public memory_resource { public: [[__gnu__::__nonnull__]] unsynchronized_pool_resource(const pool_options& __opts, memory_resource* __upstream); unsynchronized_pool_resource() : unsynchronized_pool_resource(pool_options(), get_default_resource()) { } [[__gnu__::__nonnull__]] explicit unsynchronized_pool_resource(memory_resource* __upstream) : unsynchronized_pool_resource(pool_options(), __upstream) { } explicit unsynchronized_pool_resource(const pool_options& __opts) : unsynchronized_pool_resource(__opts, get_default_resource()) { } unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete; virtual ~unsynchronized_pool_resource(); unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete; void release(); [[__gnu__::__returns_nonnull__]] memory_resource* upstream_resource() const noexcept { return _M_impl.resource(); } pool_options options() const noexcept { return _M_impl._M_opts; } protected: void* do_allocate(size_t __bytes, size_t __alignment) override; void do_deallocate(void* __p, size_t __bytes, size_t __alignment) override; bool do_is_equal(const memory_resource& __other) const noexcept override { return this == &__other; } private: using _Pool = __pool_resource::_Pool; auto _M_find_pool(size_t) noexcept; __pool_resource _M_impl; _Pool* _M_pools = nullptr; }; class monotonic_buffer_resource : public memory_resource { public: explicit monotonic_buffer_resource(memory_resource* __upstream) noexcept __attribute__((__nonnull__)) : _M_upstream(__upstream) { ; } monotonic_buffer_resource(size_t __initial_size, memory_resource* __upstream) noexcept __attribute__((__nonnull__)) : _M_next_bufsiz(__initial_size), _M_upstream(__upstream) { ; ; } monotonic_buffer_resource(void* __buffer, size_t __buffer_size, memory_resource* __upstream) noexcept __attribute__((__nonnull__(4))) : _M_current_buf(__buffer), _M_avail(__buffer_size), _M_next_bufsiz(_S_next_bufsize(__buffer_size)), _M_upstream(__upstream), _M_orig_buf(__buffer), _M_orig_size(__buffer_size) { ; ; } monotonic_buffer_resource() noexcept : monotonic_buffer_resource(get_default_resource()) { } explicit monotonic_buffer_resource(size_t __initial_size) noexcept : monotonic_buffer_resource(__initial_size, get_default_resource()) { } monotonic_buffer_resource(void* __buffer, size_t __buffer_size) noexcept : monotonic_buffer_resource(__buffer, __buffer_size, get_default_resource()) { } monotonic_buffer_resource(const monotonic_buffer_resource&) = delete; virtual ~monotonic_buffer_resource(); monotonic_buffer_resource& operator=(const monotonic_buffer_resource&) = delete; void release() noexcept { if (_M_head) _M_release_buffers(); if ((_M_current_buf = _M_orig_buf)) { _M_avail = _M_orig_size; _M_next_bufsiz = _S_next_bufsize(_M_orig_size); } else { _M_avail = 0; _M_next_bufsiz = _M_orig_size; } } memory_resource* upstream_resource() const noexcept __attribute__((__returns_nonnull__)) { return _M_upstream; } protected: void* do_allocate(size_t __bytes, size_t __alignment) override { if (__bytes == 0) __bytes = 1; void* __p = std::align(__alignment, __bytes, _M_current_buf, _M_avail); if (!__p) { _M_new_buffer(__bytes, __alignment); __p = _M_current_buf; } _M_current_buf = (char*)_M_current_buf + __bytes; _M_avail -= __bytes; return __p; } void do_deallocate(void*, size_t, size_t) override { } bool do_is_equal(const memory_resource& __other) const noexcept override { return this == &__other; } private: void _M_new_buffer(size_t __bytes, size_t __alignment); void _M_release_buffers() noexcept; static size_t _S_next_bufsize(size_t __buffer_size) noexcept { if (__buffer_size == 0) __buffer_size = 1; return __buffer_size * _S_growth_factor; } static constexpr size_t _S_init_bufsize = 128 * sizeof(void*); static constexpr float _S_growth_factor = 1.5; void* _M_current_buf = nullptr; size_t _M_avail = 0; size_t _M_next_bufsiz = _S_init_bufsize; memory_resource* const _M_upstream; void* const _M_orig_buf = nullptr; size_t const _M_orig_size = _M_next_bufsiz; class _Chunk; _Chunk* _M_head = nullptr; }; } } # 34 "all-std.cxx" 2 # 1 "/usr/include/c++/10/scoped_allocator" 1 3 # 33 "/usr/include/c++/10/scoped_allocator" 3 # 34 "/usr/include/c++/10/scoped_allocator" 3 # 44 "/usr/include/c++/10/scoped_allocator" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 55 "/usr/include/c++/10/scoped_allocator" 3 template using __outer_allocator_t = decltype(std::declval<_Alloc>().outer_allocator()); template struct __outermost_type { using type = _Alloc; static type& _S_outermost(_Alloc& __a) { return __a; } }; template struct __outermost_type<_Alloc, __void_t<__outer_allocator_t<_Alloc>>> : __outermost_type< typename remove_reference<__outer_allocator_t<_Alloc>>::type > { using __base = __outermost_type< typename remove_reference<__outer_allocator_t<_Alloc>>::type >; static typename __base::type& _S_outermost(_Alloc& __a) { return __base::_S_outermost(__a.outer_allocator()); } }; template inline typename __outermost_type<_Alloc>::type& __outermost(_Alloc& __a) { return __outermost_type<_Alloc>::_S_outermost(__a); } template class scoped_allocator_adaptor; template struct __inner_type_impl; template struct __inner_type_impl<_Outer> { typedef scoped_allocator_adaptor<_Outer> __type; __inner_type_impl() = default; __inner_type_impl(const __inner_type_impl&) = default; __inner_type_impl(__inner_type_impl&&) = default; __inner_type_impl& operator=(const __inner_type_impl&) = default; __inner_type_impl& operator=(__inner_type_impl&&) = default; template __inner_type_impl(const __inner_type_impl<_Alloc>& __other) { } template __inner_type_impl(__inner_type_impl<_Alloc>&& __other) { } __type& _M_get(__type* __p) noexcept { return *__p; } const __type& _M_get(const __type* __p) const noexcept { return *__p; } tuple<> _M_tie() const noexcept { return tuple<>(); } bool operator==(const __inner_type_impl&) const noexcept { return true; } }; template struct __inner_type_impl<_Outer, _InnerHead, _InnerTail...> { typedef scoped_allocator_adaptor<_InnerHead, _InnerTail...> __type; __inner_type_impl() = default; __inner_type_impl(const __inner_type_impl&) = default; __inner_type_impl(__inner_type_impl&&) = default; __inner_type_impl& operator=(const __inner_type_impl&) = default; __inner_type_impl& operator=(__inner_type_impl&&) = default; template __inner_type_impl(const __inner_type_impl<_Allocs...>& __other) : _M_inner(__other._M_inner) { } template __inner_type_impl(__inner_type_impl<_Allocs...>&& __other) : _M_inner(std::move(__other._M_inner)) { } template explicit __inner_type_impl(_Args&&... __args) : _M_inner(std::forward<_Args>(__args)...) { } __type& _M_get(void*) noexcept { return _M_inner; } const __type& _M_get(const void*) const noexcept { return _M_inner; } tuple _M_tie() const noexcept { return _M_inner._M_tie(); } bool operator==(const __inner_type_impl& __other) const noexcept { return _M_inner == __other._M_inner; } private: template friend class __inner_type_impl; template friend class scoped_allocator_adaptor; __type _M_inner; }; template class scoped_allocator_adaptor : public _OuterAlloc { typedef allocator_traits<_OuterAlloc> __traits; typedef __inner_type_impl<_OuterAlloc, _InnerAllocs...> __inner_type; __inner_type _M_inner; template friend class scoped_allocator_adaptor; template friend class __inner_type_impl; tuple _M_tie() const noexcept { return std::tuple_cat(std::tie(outer_allocator()), _M_inner._M_tie()); } template using __outermost_alloc_traits = allocator_traits::type>; # 231 "/usr/include/c++/10/scoped_allocator" 3 template static _Alloc _S_select_on_copy(const _Alloc& __a) { typedef allocator_traits<_Alloc> __a_traits; return __a_traits::select_on_container_copy_construction(__a); } template scoped_allocator_adaptor(tuple __refs, _Index_tuple<_Indices...>) : _OuterAlloc(_S_select_on_copy(std::get<0>(__refs))), _M_inner(_S_select_on_copy(std::get<_Indices+1>(__refs))...) { } template using _Constructible = typename enable_if< is_constructible<_OuterAlloc, _Alloc>::value >::type; template struct __not_pair { using type = void; }; template struct __not_pair> { }; public: typedef _OuterAlloc outer_allocator_type; typedef typename __inner_type::__type inner_allocator_type; typedef typename __traits::value_type value_type; typedef typename __traits::size_type size_type; typedef typename __traits::difference_type difference_type; typedef typename __traits::pointer pointer; typedef typename __traits::const_pointer const_pointer; typedef typename __traits::void_pointer void_pointer; typedef typename __traits::const_void_pointer const_void_pointer; typedef typename __or_< typename __traits::propagate_on_container_copy_assignment, typename allocator_traits<_InnerAllocs>:: propagate_on_container_copy_assignment...>::type propagate_on_container_copy_assignment; typedef typename __or_< typename __traits::propagate_on_container_move_assignment, typename allocator_traits<_InnerAllocs>:: propagate_on_container_move_assignment...>::type propagate_on_container_move_assignment; typedef typename __or_< typename __traits::propagate_on_container_swap, typename allocator_traits<_InnerAllocs>:: propagate_on_container_swap...>::type propagate_on_container_swap; typedef typename __and_< typename __traits::is_always_equal, typename allocator_traits<_InnerAllocs>::is_always_equal...>::type is_always_equal; template struct rebind { typedef scoped_allocator_adaptor< typename __traits::template rebind_alloc<_Tp>, _InnerAllocs...> other; }; scoped_allocator_adaptor() : _OuterAlloc(), _M_inner() { } template> scoped_allocator_adaptor(_Outer2&& __outer, const _InnerAllocs&... __inner) : _OuterAlloc(std::forward<_Outer2>(__outer)), _M_inner(__inner...) { } scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) : _OuterAlloc(__other.outer_allocator()), _M_inner(__other._M_inner) { } scoped_allocator_adaptor(scoped_allocator_adaptor&& __other) : _OuterAlloc(std::move(__other.outer_allocator())), _M_inner(std::move(__other._M_inner)) { } template> scoped_allocator_adaptor( const scoped_allocator_adaptor<_Outer2, _InnerAllocs...>& __other) : _OuterAlloc(__other.outer_allocator()), _M_inner(__other._M_inner) { } template> scoped_allocator_adaptor( scoped_allocator_adaptor<_Outer2, _InnerAllocs...>&& __other) : _OuterAlloc(std::move(__other.outer_allocator())), _M_inner(std::move(__other._M_inner)) { } scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default; scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default; inner_allocator_type& inner_allocator() noexcept { return _M_inner._M_get(this); } const inner_allocator_type& inner_allocator() const noexcept { return _M_inner._M_get(this); } outer_allocator_type& outer_allocator() noexcept { return static_cast<_OuterAlloc&>(*this); } const outer_allocator_type& outer_allocator() const noexcept { return static_cast(*this); } [[__nodiscard__]] pointer allocate(size_type __n) { return __traits::allocate(outer_allocator(), __n); } [[__nodiscard__]] pointer allocate(size_type __n, const_void_pointer __hint) { return __traits::allocate(outer_allocator(), __n, __hint); } void deallocate(pointer __p, size_type __n) { return __traits::deallocate(outer_allocator(), __p, __n); } size_type max_size() const { return __traits::max_size(outer_allocator()); } # 431 "/usr/include/c++/10/scoped_allocator" 3 template __attribute__((__nonnull__)) void construct(_Tp* __p, _Args&&... __args) { typedef __outermost_alloc_traits _O_traits; std::apply([__p, this](auto&&... __newargs) { _O_traits::construct(__outermost(*this), __p, std::forward(__newargs)...); }, uses_allocator_construction_args<_Tp>(inner_allocator(), std::forward<_Args>(__args)...)); } template void destroy(_Tp* __p) { typedef __outermost_alloc_traits _O_traits; _O_traits::destroy(__outermost(*this), __p); } scoped_allocator_adaptor select_on_container_copy_construction() const { typedef typename _Build_index_tuple::__type _Indices; return scoped_allocator_adaptor(_M_tie(), _Indices()); } template friend bool operator==(const scoped_allocator_adaptor<_OutA1, _InA...>& __a, const scoped_allocator_adaptor<_OutA2, _InA...>& __b) noexcept; private: # 491 "/usr/include/c++/10/scoped_allocator" 3 }; template inline bool operator==(const scoped_allocator_adaptor<_OutA1, _InA...>& __a, const scoped_allocator_adaptor<_OutA2, _InA...>& __b) noexcept { return __a.outer_allocator() == __b.outer_allocator() && __a._M_inner == __b._M_inner; } # 514 "/usr/include/c++/10/scoped_allocator" 3 } # 36 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cfloat" 1 3 # 39 "/usr/include/c++/10/cfloat" 3 # 40 "/usr/include/c++/10/cfloat" 3 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/float.h" 1 3 4 # 43 "/usr/include/c++/10/cfloat" 2 3 # 37 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cinttypes" 1 3 # 32 "/usr/include/c++/10/cinttypes" 3 # 33 "/usr/include/c++/10/cinttypes" 3 # 46 "/usr/include/c++/10/cinttypes" 3 # 1 "/usr/include/inttypes.h" 1 3 4 # 266 "/usr/include/inttypes.h" 3 4 extern "C" { typedef struct { long int quot; long int rem; } imaxdiv_t; # 290 "/usr/include/inttypes.h" 3 4 extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__)); extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) throw () __attribute__ ((__const__)); extern intmax_t strtoimax (const char *__restrict __nptr, char **__restrict __endptr, int __base) throw (); extern uintmax_t strtoumax (const char *__restrict __nptr, char ** __restrict __endptr, int __base) throw (); extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw (); extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, wchar_t ** __restrict __endptr, int __base) throw (); # 432 "/usr/include/inttypes.h" 3 4 } # 47 "/usr/include/c++/10/cinttypes" 2 3 # 55 "/usr/include/c++/10/cinttypes" 3 namespace std { using ::imaxdiv_t; using ::imaxabs; using ::imaxdiv; using ::strtoimax; using ::strtoumax; using ::wcstoimax; using ::wcstoumax; } # 38 "all-std.cxx" 2 # 1 "/usr/include/c++/10/climits" 1 3 # 39 "/usr/include/c++/10/climits" 3 # 40 "/usr/include/c++/10/climits" 3 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4 # 34 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/syslimits.h" 1 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4 # 195 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 3 4 # 1 "/usr/include/limits.h" 1 3 4 # 26 "/usr/include/limits.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 27 "/usr/include/limits.h" 2 3 4 # 183 "/usr/include/limits.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4 # 27 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4 # 28 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 # 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4 # 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4 # 1 "/usr/include/linux/limits.h" 1 3 4 # 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4 # 162 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4 # 184 "/usr/include/limits.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4 # 188 "/usr/include/limits.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4 # 64 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/uio_lim.h" 1 3 4 # 65 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4 # 192 "/usr/include/limits.h" 2 3 4 # 196 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 2 3 4 # 8 "/usr/lib/gcc/x86_64-linux-gnu/10/include/syslimits.h" 2 3 4 # 35 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 2 3 4 # 43 "/usr/include/c++/10/climits" 2 3 # 39 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cassert" 1 3 # 41 "/usr/include/c++/10/cassert" 3 # 42 "/usr/include/c++/10/cassert" 3 # 1 "/usr/include/assert.h" 1 3 4 # 66 "/usr/include/assert.h" 3 4 extern "C" { extern void __assert_fail (const char *__assertion, const char *__file, unsigned int __line, const char *__function) throw () __attribute__ ((__noreturn__)); extern void __assert_perror_fail (int __errnum, const char *__file, unsigned int __line, const char *__function) throw () __attribute__ ((__noreturn__)); extern void __assert (const char *__assertion, const char *__file, int __line) throw () __attribute__ ((__noreturn__)); } # 45 "/usr/include/c++/10/cassert" 2 3 # 42 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cerrno" 1 3 # 39 "/usr/include/c++/10/cerrno" 3 # 40 "/usr/include/c++/10/cerrno" 3 # 43 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cctype" 1 3 # 39 "/usr/include/c++/10/cctype" 3 # 40 "/usr/include/c++/10/cctype" 3 # 47 "all-std.cxx" 2 # 1 "/usr/include/c++/10/charconv" 1 3 # 32 "/usr/include/c++/10/charconv" 3 # 33 "/usr/include/c++/10/charconv" 3 # 42 "/usr/include/c++/10/charconv" 3 # 1 "/usr/include/c++/10/cctype" 1 3 # 39 "/usr/include/c++/10/cctype" 3 # 40 "/usr/include/c++/10/cctype" 3 # 43 "/usr/include/c++/10/charconv" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct to_chars_result { char* ptr; errc ec; friend bool operator==(const to_chars_result&, const to_chars_result&) = default; }; struct from_chars_result { const char* ptr; errc ec; friend bool operator==(const from_chars_result&, const from_chars_result&) = default; }; namespace __detail { template using __integer_to_chars_result_type = enable_if_t<__or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>, is_same>>::value, to_chars_result>; template struct __to_chars_unsigned_type : __make_unsigned_selector_base { using _UInts = _List; using type = typename __select::__type; }; template using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type; template constexpr unsigned __to_chars_len(_Tp __value, int __base ) noexcept; template constexpr unsigned __to_chars_len_2(_Tp __value) noexcept { return std::__bit_width(__value); } template to_chars_result __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "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; static 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 __integer_to_chars_result_type<_Tp> __to_chars_16(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "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; } static 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 inline __integer_to_chars_result_type<_Tp> __to_chars_10(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "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 __integer_to_chars_result_type<_Tp> __to_chars_8(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); to_chars_result __res; unsigned __len; 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 __integer_to_chars_result_type<_Tp> __to_chars_2(char* __first, char* __last, _Tp __val) noexcept { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "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 __detail::__integer_to_chars_result_type<_Tp> __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10) { ; 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{} }; } if constexpr (std::is_signed<_Tp>::value) if (__value < 0) { if (__builtin_expect(__first != __last, 1)) *__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); } } inline to_chars_result to_chars(char* __first, char* __last, char __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, signed char __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, unsigned char __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, signed short __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, unsigned short __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, signed int __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, unsigned int __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, signed long __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, unsigned long __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, signed long long __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } inline to_chars_result to_chars(char* __first, char* __last, unsigned long long __value, int __base = 10) { return std::__to_chars_i(__first, __last, __value, __base); } # 397 "/usr/include/c++/10/charconv" 3 to_chars_result to_chars(char*, char*, bool, int = 10) = delete; namespace __detail { template 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 __from_chars_binary(const char*& __first, const char* __last, _Tp& __val) { static_assert(is_integral<_Tp>::value, "implementation bug"); static_assert(is_unsigned<_Tp>::value, "implementation bug"); const ptrdiff_t __len = __last - __first; ptrdiff_t __i = 0; while (__i < __len && __first[__i] == '0') ++__i; const ptrdiff_t __leading_zeroes = __i; while (__i < __len) { const unsigned char __c = (unsigned)__first[__i] - '0'; if (__c < 2) __val = (__val << 1) | __c; else break; __i++; } __first += __i; return (__i - __leading_zeroes) <= __gnu_cxx::__int_traits<_Tp>::__digits; } template bool __from_chars_digit(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"); auto __matches = [__base](char __c) { return '0' <= __c && __c <= ('0' + (__base - 1)); }; while (__first != __last) { const char __c = *__first; if (__matches(__c)) { if (!__raise_and_add(__val, __base, __c - '0')) { while (++__first != __last && __matches(*__first)) ; return false; } __first++; } else return true; } return true; } constexpr unsigned char __from_chars_alpha_to_num(char __c) { switch (__c) { case 'a': case 'A': return 10; case 'b': case 'B': return 11; case 'c': case 'C': return 12; case 'd': case 'D': return 13; case 'e': case 'E': return 14; case 'f': case 'F': return 15; case 'g': case 'G': return 16; case 'h': case 'H': return 17; case 'i': case 'I': return 18; case 'j': case 'J': return 19; case 'k': case 'K': return 20; case 'l': case 'L': return 21; case 'm': case 'M': return 22; case 'n': case 'N': return 23; case 'o': case 'O': return 24; case 'p': case 'P': return 25; case 'q': case 'Q': return 26; case 'r': case 'R': return 27; case 's': case 'S': return 28; case 't': case 'T': return 29; case 'u': case 'U': return 30; case 'v': case 'V': return 31; case 'w': case 'W': return 32; case 'x': case 'X': return 33; case 'y': case 'Y': return 34; case 'z': case 'Z': return 35; } return __gnu_cxx::__int_traits::__max; } template bool __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val, int __base) { bool __valid = true; while (__first != __last) { unsigned char __c = *__first; if (std::isdigit(__c)) __c -= '0'; else { __c = __from_chars_alpha_to_num(__c); if (__c >= __base) break; } if (__builtin_expect(__valid, 1)) __valid = __raise_and_add(__val, __base, __c); __first++; } return __valid; } template using __integer_from_chars_result_type = enable_if_t<__or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>, is_same>>::value, from_chars_result>; } template __detail::__integer_from_chars_result_type<_Tp> from_chars(const char* __first, const char* __last, _Tp& __value, int __base = 10) { ; 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 == 2) __valid = __detail::__from_chars_binary(__first, __last, __val); else if (__base <= 10) __valid = __detail::__from_chars_digit(__first, __last, __val, __base); else __valid = __detail::__from_chars_alnum(__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 }; constexpr chars_format operator|(chars_format __lhs, chars_format __rhs) noexcept { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); } constexpr chars_format operator&(chars_format __lhs, chars_format __rhs) noexcept { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); } constexpr chars_format operator^(chars_format __lhs, chars_format __rhs) noexcept { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); } 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; } } # 48 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cstring" 1 3 # 39 "/usr/include/c++/10/cstring" 3 # 40 "/usr/include/c++/10/cstring" 3 # 1 "/usr/include/string.h" 1 3 4 # 26 "/usr/include/string.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 27 "/usr/include/string.h" 2 3 4 extern "C" { # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 34 "/usr/include/string.h" 2 3 4 # 43 "/usr/include/string.h" 3 4 extern void *memcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern void *memmove (void *__dest, const void *__src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern void *memccpy (void *__restrict __dest, const void *__restrict __src, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1))); extern int memcmp (const void *__s1, const void *__s2, size_t __n) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern "C++" { extern void *memchr (void *__s, int __c, size_t __n) throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const void *memchr (const void *__s, int __c, size_t __n) throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 89 "/usr/include/string.h" 3 4 } # 99 "/usr/include/string.h" 3 4 extern "C++" void *rawmemchr (void *__s, int __c) throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern "C++" const void *rawmemchr (const void *__s, int __c) throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern "C++" void *memrchr (void *__s, int __c, size_t __n) throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 122 "/usr/include/string.h" 3 4 extern char *strcpy (char *__restrict __dest, const char *__restrict __src) throw () __attribute__ ((__nonnull__ (1, 2))); extern char *strncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern char *strcat (char *__restrict __dest, const char *__restrict __src) throw () __attribute__ ((__nonnull__ (1, 2))); extern char *strncat (char *__restrict __dest, const char *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern int strcmp (const char *__s1, const char *__s2) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strncmp (const char *__s1, const char *__s2, size_t __n) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strcoll (const char *__s1, const char *__s2) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern size_t strxfrm (char *__restrict __dest, const char *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (2))); extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4))); extern char *strdup (const char *__s) throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); extern char *strndup (const char *__string, size_t __n) throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); # 204 "/usr/include/string.h" 3 4 extern "C++" { extern char *strchr (char *__s, int __c) throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *strchr (const char *__s, int __c) throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 224 "/usr/include/string.h" 3 4 } extern "C++" { extern char *strrchr (char *__s, int __c) throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *strrchr (const char *__s, int __c) throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 251 "/usr/include/string.h" 3 4 } # 261 "/usr/include/string.h" 3 4 extern "C++" char *strchrnul (char *__s, int __c) throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern "C++" const char *strchrnul (const char *__s, int __c) throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 273 "/usr/include/string.h" 3 4 extern size_t strcspn (const char *__s, const char *__reject) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern size_t strspn (const char *__s, const char *__accept) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern "C++" { extern char *strpbrk (char *__s, const char *__accept) throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern const char *strpbrk (const char *__s, const char *__accept) throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); # 301 "/usr/include/string.h" 3 4 } extern "C++" { extern char *strstr (char *__haystack, const char *__needle) throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern const char *strstr (const char *__haystack, const char *__needle) throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); # 328 "/usr/include/string.h" 3 4 } extern char *strtok (char *__restrict __s, const char *__restrict __delim) throw () __attribute__ ((__nonnull__ (2))); extern char *__strtok_r (char *__restrict __s, const char *__restrict __delim, char **__restrict __save_ptr) throw () __attribute__ ((__nonnull__ (2, 3))); extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, char **__restrict __save_ptr) throw () __attribute__ ((__nonnull__ (2, 3))); extern "C++" char *strcasestr (char *__haystack, const char *__needle) throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern "C++" const char *strcasestr (const char *__haystack, const char *__needle) throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); # 369 "/usr/include/string.h" 3 4 extern void *memmem (const void *__haystack, size_t __haystacklen, const void *__needle, size_t __needlelen) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))); extern void *__mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern void *mempcpy (void *__restrict __dest, const void *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern size_t strlen (const char *__s) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern size_t strnlen (const char *__string, size_t __maxlen) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern char *strerror (int __errnum) throw (); # 421 "/usr/include/string.h" 3 4 extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) throw () __attribute__ ((__nonnull__ (2))) ; extern char *strerror_l (int __errnum, locale_t __l) throw (); # 1 "/usr/include/strings.h" 1 3 4 # 23 "/usr/include/strings.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 24 "/usr/include/strings.h" 2 3 4 extern "C" { extern int bcmp (const void *__s1, const void *__s2, size_t __n) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern void bcopy (const void *__src, void *__dest, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); extern "C++" { extern char *index (char *__s, int __c) throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *index (const char *__s, int __c) throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 66 "/usr/include/strings.h" 3 4 } extern "C++" { extern char *rindex (char *__s, int __c) throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); extern const char *rindex (const char *__s, int __c) throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); # 94 "/usr/include/strings.h" 3 4 } # 104 "/usr/include/strings.h" 3 4 extern int ffs (int __i) throw () __attribute__ ((__const__)); extern int ffsl (long int __l) throw () __attribute__ ((__const__)); __extension__ extern int ffsll (long long int __ll) throw () __attribute__ ((__const__)); extern int strcasecmp (const char *__s1, const char *__s2) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); extern int strncasecmp_l (const char *__s1, const char *__s2, size_t __n, locale_t __loc) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); } # 433 "/usr/include/string.h" 2 3 4 extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); extern char *strsep (char **__restrict __stringp, const char *__restrict __delim) throw () __attribute__ ((__nonnull__ (1, 2))); extern char *strsignal (int __sig) throw (); extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) throw () __attribute__ ((__nonnull__ (1, 2))); extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) throw () __attribute__ ((__nonnull__ (1, 2))); extern char *__stpncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern char *stpncpy (char *__restrict __dest, const char *__restrict __src, size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); extern int strverscmp (const char *__s1, const char *__s2) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1))); extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); extern "C++" char *basename (char *__filename) throw () __asm ("basename") __attribute__ ((__nonnull__ (1))); extern "C++" const char *basename (const char *__filename) throw () __asm ("basename") __attribute__ ((__nonnull__ (1))); # 499 "/usr/include/string.h" 3 4 } # 43 "/usr/include/c++/10/cstring" 2 3 # 71 "/usr/include/c++/10/cstring" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::memchr; using ::memcmp; using ::memcpy; using ::memmove; using ::memset; using ::strcat; using ::strcmp; using ::strcoll; using ::strcpy; using ::strcspn; using ::strerror; using ::strlen; using ::strncat; using ::strncmp; using ::strncpy; using ::strspn; using ::strtok; using ::strxfrm; using ::strchr; using ::strpbrk; using ::strrchr; using ::strstr; # 122 "/usr/include/c++/10/cstring" 3 } } # 49 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cuchar" 1 3 # 42 "/usr/include/c++/10/cuchar" 3 # 43 "/usr/include/c++/10/cuchar" 3 # 1 "/usr/include/c++/10/cwchar" 1 3 # 39 "/usr/include/c++/10/cwchar" 3 # 40 "/usr/include/c++/10/cwchar" 3 # 50 "/usr/include/c++/10/cuchar" 2 3 # 1 "/usr/include/uchar.h" 1 3 4 # 29 "/usr/include/uchar.h" 3 4 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 30 "/usr/include/uchar.h" 2 3 4 # 41 "/usr/include/uchar.h" 3 4 extern "C" { extern size_t mbrtoc16 (char16_t *__restrict __pc16, const char *__restrict __s, size_t __n, mbstate_t *__restrict __p) throw (); extern size_t c16rtomb (char *__restrict __s, char16_t __c16, mbstate_t *__restrict __ps) throw (); extern size_t mbrtoc32 (char32_t *__restrict __pc32, const char *__restrict __s, size_t __n, mbstate_t *__restrict __p) throw (); extern size_t c32rtomb (char *__restrict __s, char32_t __c32, mbstate_t *__restrict __ps) throw (); } # 54 "/usr/include/c++/10/cuchar" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { using ::mbrtoc16; using ::c16rtomb; using ::mbrtoc32; using ::c32rtomb; } # 50 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cwchar" 1 3 # 39 "/usr/include/c++/10/cwchar" 3 # 40 "/usr/include/c++/10/cwchar" 3 # 51 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cwctype" 1 3 # 39 "/usr/include/c++/10/cwctype" 3 # 40 "/usr/include/c++/10/cwctype" 3 # 52 "all-std.cxx" 2 # 1 "/usr/include/c++/10/deque" 1 3 # 58 "/usr/include/c++/10/deque" 3 # 59 "/usr/include/c++/10/deque" 3 # 67 "/usr/include/c++/10/deque" 3 # 1 "/usr/include/c++/10/bits/stl_deque.h" 1 3 # 72 "/usr/include/c++/10/bits/stl_deque.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 95 "/usr/include/c++/10/bits/stl_deque.h" 3 constexpr inline size_t __deque_buf_size(size_t __size) { return (__size < 512 ? size_t(512 / __size) : size_t(1)); } # 112 "/usr/include/c++/10/bits/stl_deque.h" 3 template struct _Deque_iterator { private: template using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_rebind<_Ptr, _CvTp>>; public: typedef __iter<_Tp> iterator; typedef __iter const_iterator; typedef __ptr_rebind<_Ptr, _Tp> _Elt_pointer; typedef __ptr_rebind<_Ptr, _Elt_pointer> _Map_pointer; static size_t _S_buffer_size() noexcept { return __deque_buf_size(sizeof(_Tp)); } typedef std::random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef _Ptr pointer; typedef _Ref reference; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Deque_iterator _Self; _Elt_pointer _M_cur; _Elt_pointer _M_first; _Elt_pointer _M_last; _Map_pointer _M_node; _Deque_iterator(_Elt_pointer __x, _Map_pointer __y) noexcept : _M_cur(__x), _M_first(*__y), _M_last(*__y + _S_buffer_size()), _M_node(__y) { } _Deque_iterator() noexcept : _M_cur(), _M_first(), _M_last(), _M_node() { } # 161 "/usr/include/c++/10/bits/stl_deque.h" 3 template, is_same<_Iter, iterator>>> _Deque_iterator(const _Iter& __x) noexcept : _M_cur(__x._M_cur), _M_first(__x._M_first), _M_last(__x._M_last), _M_node(__x._M_node) { } _Deque_iterator(const _Deque_iterator& __x) noexcept : _M_cur(__x._M_cur), _M_first(__x._M_first), _M_last(__x._M_last), _M_node(__x._M_node) { } _Deque_iterator& operator=(const _Deque_iterator&) = default; iterator _M_const_cast() const noexcept { return iterator(_M_cur, _M_node); } reference operator*() const noexcept { return *_M_cur; } pointer operator->() const noexcept { return _M_cur; } _Self& operator++() noexcept { ++_M_cur; if (_M_cur == _M_last) { _M_set_node(_M_node + 1); _M_cur = _M_first; } return *this; } _Self operator++(int) noexcept { _Self __tmp = *this; ++*this; return __tmp; } _Self& operator--() noexcept { if (_M_cur == _M_first) { _M_set_node(_M_node - 1); _M_cur = _M_last; } --_M_cur; return *this; } _Self operator--(int) noexcept { _Self __tmp = *this; --*this; return __tmp; } _Self& operator+=(difference_type __n) noexcept { const difference_type __offset = __n + (_M_cur - _M_first); if (__offset >= 0 && __offset < difference_type(_S_buffer_size())) _M_cur += __n; else { const difference_type __node_offset = __offset > 0 ? __offset / difference_type(_S_buffer_size()) : -difference_type((-__offset - 1) / _S_buffer_size()) - 1; _M_set_node(_M_node + __node_offset); _M_cur = _M_first + (__offset - __node_offset * difference_type(_S_buffer_size())); } return *this; } _Self& operator-=(difference_type __n) noexcept { return *this += -__n; } reference operator[](difference_type __n) const noexcept { return *(*this + __n); } void _M_set_node(_Map_pointer __new_node) noexcept { _M_node = __new_node; _M_first = *__new_node; _M_last = _M_first + difference_type(_S_buffer_size()); } friend bool operator==(const _Self& __x, const _Self& __y) noexcept { return __x._M_cur == __y._M_cur; } template friend bool operator==(const _Self& __x, const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept { return __x._M_cur == __y._M_cur; } friend strong_ordering operator<=>(const _Self& __x, const _Self& __y) noexcept { if (const auto __cmp = __x._M_node <=> __y._M_node; __cmp != 0) return __cmp; return __x._M_cur <=> __y._M_cur; } # 352 "/usr/include/c++/10/bits/stl_deque.h" 3 friend difference_type operator-(const _Self& __x, const _Self& __y) noexcept { return difference_type(_S_buffer_size()) * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) + (__y._M_last - __y._M_cur); } template friend difference_type operator-(const _Self& __x, const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept { return difference_type(_S_buffer_size()) * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) + (__y._M_last - __y._M_cur); } friend _Self operator+(const _Self& __x, difference_type __n) noexcept { _Self __tmp = __x; __tmp += __n; return __tmp; } friend _Self operator-(const _Self& __x, difference_type __n) noexcept { _Self __tmp = __x; __tmp -= __n; return __tmp; } friend _Self operator+(difference_type __n, const _Self& __x) noexcept { return __x + __n; } }; # 405 "/usr/include/c++/10/bits/stl_deque.h" 3 template class _Deque_base { protected: typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type; typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; typedef typename _Alloc_traits::pointer _Ptr; typedef typename _Alloc_traits::const_pointer _Ptr_const; typedef typename _Alloc_traits::template rebind<_Ptr>::other _Map_alloc_type; typedef __gnu_cxx::__alloc_traits<_Map_alloc_type> _Map_alloc_traits; typedef _Alloc allocator_type; allocator_type get_allocator() const noexcept { return allocator_type(_M_get_Tp_allocator()); } typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator; typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> const_iterator; _Deque_base() : _M_impl() { _M_initialize_map(0); } _Deque_base(size_t __num_elements) : _M_impl() { _M_initialize_map(__num_elements); } _Deque_base(const allocator_type& __a, size_t __num_elements) : _M_impl(__a) { _M_initialize_map(__num_elements); } _Deque_base(const allocator_type& __a) : _M_impl(__a) { } _Deque_base(_Deque_base&& __x) : _M_impl(std::move(__x._M_get_Tp_allocator())) { _M_initialize_map(0); if (__x._M_impl._M_map) this->_M_impl._M_swap_data(__x._M_impl); } _Deque_base(_Deque_base&& __x, const allocator_type& __a) : _M_impl(std::move(__x._M_impl), _Tp_alloc_type(__a)) { __x._M_initialize_map(0); } _Deque_base(_Deque_base&& __x, const allocator_type& __a, size_t __n) : _M_impl(__a) { if (__x.get_allocator() == __a) { if (__x._M_impl._M_map) { _M_initialize_map(0); this->_M_impl._M_swap_data(__x._M_impl); } } else { _M_initialize_map(__n); } } ~_Deque_base() noexcept; typedef typename iterator::_Map_pointer _Map_pointer; struct _Deque_impl_data { _Map_pointer _M_map; size_t _M_map_size; iterator _M_start; iterator _M_finish; _Deque_impl_data() noexcept : _M_map(), _M_map_size(), _M_start(), _M_finish() { } _Deque_impl_data(const _Deque_impl_data&) = default; _Deque_impl_data& operator=(const _Deque_impl_data&) = default; _Deque_impl_data(_Deque_impl_data&& __x) noexcept : _Deque_impl_data(__x) { __x = _Deque_impl_data(); } void _M_swap_data(_Deque_impl_data& __x) noexcept { std::swap(*this, __x); } }; struct _Deque_impl : public _Tp_alloc_type, public _Deque_impl_data { _Deque_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) : _Tp_alloc_type() { } _Deque_impl(const _Tp_alloc_type& __a) noexcept : _Tp_alloc_type(__a) { } _Deque_impl(_Deque_impl&&) = default; _Deque_impl(_Tp_alloc_type&& __a) noexcept : _Tp_alloc_type(std::move(__a)) { } _Deque_impl(_Deque_impl&& __d, _Tp_alloc_type&& __a) : _Tp_alloc_type(std::move(__a)), _Deque_impl_data(std::move(__d)) { } }; _Tp_alloc_type& _M_get_Tp_allocator() noexcept { return this->_M_impl; } const _Tp_alloc_type& _M_get_Tp_allocator() const noexcept { return this->_M_impl; } _Map_alloc_type _M_get_map_allocator() const noexcept { return _Map_alloc_type(_M_get_Tp_allocator()); } _Ptr _M_allocate_node() { typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits; return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp))); } void _M_deallocate_node(_Ptr __p) noexcept { typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits; _Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp))); } _Map_pointer _M_allocate_map(size_t __n) { _Map_alloc_type __map_alloc = _M_get_map_allocator(); return _Map_alloc_traits::allocate(__map_alloc, __n); } void _M_deallocate_map(_Map_pointer __p, size_t __n) noexcept { _Map_alloc_type __map_alloc = _M_get_map_allocator(); _Map_alloc_traits::deallocate(__map_alloc, __p, __n); } void _M_initialize_map(size_t); void _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish); void _M_destroy_nodes(_Map_pointer __nstart, _Map_pointer __nfinish) noexcept; enum { _S_initial_map_size = 8 }; _Deque_impl _M_impl; }; template _Deque_base<_Tp, _Alloc>:: ~_Deque_base() noexcept { if (this->_M_impl._M_map) { _M_destroy_nodes(this->_M_impl._M_start._M_node, this->_M_impl._M_finish._M_node + 1); _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); } } # 612 "/usr/include/c++/10/bits/stl_deque.h" 3 template void _Deque_base<_Tp, _Alloc>:: _M_initialize_map(size_t __num_elements) { const size_t __num_nodes = (__num_elements / __deque_buf_size(sizeof(_Tp)) + 1); this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size, size_t(__num_nodes + 2)); this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size); _Map_pointer __nstart = (this->_M_impl._M_map + (this->_M_impl._M_map_size - __num_nodes) / 2); _Map_pointer __nfinish = __nstart + __num_nodes; try { _M_create_nodes(__nstart, __nfinish); } catch(...) { _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); this->_M_impl._M_map = _Map_pointer(); this->_M_impl._M_map_size = 0; throw; } this->_M_impl._M_start._M_set_node(__nstart); this->_M_impl._M_finish._M_set_node(__nfinish - 1); this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first; this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first + __num_elements % __deque_buf_size(sizeof(_Tp))); } template void _Deque_base<_Tp, _Alloc>:: _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish) { _Map_pointer __cur; try { for (__cur = __nstart; __cur < __nfinish; ++__cur) *__cur = this->_M_allocate_node(); } catch(...) { _M_destroy_nodes(__nstart, __cur); throw; } } template void _Deque_base<_Tp, _Alloc>:: _M_destroy_nodes(_Map_pointer __nstart, _Map_pointer __nfinish) noexcept { for (_Map_pointer __n = __nstart; __n < __nfinish; ++__n) _M_deallocate_node(*__n); } # 763 "/usr/include/c++/10/bits/stl_deque.h" 3 template > class deque : protected _Deque_base<_Tp, _Alloc> { # 776 "/usr/include/c++/10/bits/stl_deque.h" 3 static_assert(is_same::type, _Tp>::value, "std::deque must have a non-const, non-volatile value_type"); static_assert(is_same::value, "std::deque must have the same value_type as its allocator"); typedef _Deque_base<_Tp, _Alloc> _Base; typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; typedef typename _Base::_Alloc_traits _Alloc_traits; typedef typename _Base::_Map_pointer _Map_pointer; public: typedef _Tp value_type; typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Base::iterator iterator; typedef typename _Base::const_iterator const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Alloc allocator_type; private: static size_t _S_buffer_size() noexcept { return __deque_buf_size(sizeof(_Tp)); } using _Base::_M_initialize_map; using _Base::_M_create_nodes; using _Base::_M_destroy_nodes; using _Base::_M_allocate_node; using _Base::_M_deallocate_node; using _Base::_M_allocate_map; using _Base::_M_deallocate_map; using _Base::_M_get_Tp_allocator; using _Base::_M_impl; public: deque() = default; # 840 "/usr/include/c++/10/bits/stl_deque.h" 3 explicit deque(const allocator_type& __a) : _Base(__a, 0) { } # 853 "/usr/include/c++/10/bits/stl_deque.h" 3 explicit deque(size_type __n, const allocator_type& __a = allocator_type()) : _Base(__a, _S_check_init_len(__n, __a)) { _M_default_initialize(); } # 866 "/usr/include/c++/10/bits/stl_deque.h" 3 deque(size_type __n, const value_type& __value, const allocator_type& __a = allocator_type()) : _Base(__a, _S_check_init_len(__n, __a)) { _M_fill_initialize(__value); } # 893 "/usr/include/c++/10/bits/stl_deque.h" 3 deque(const deque& __x) : _Base(_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()), __x.size()) { std::__uninitialized_copy_a(__x.begin(), __x.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); } # 909 "/usr/include/c++/10/bits/stl_deque.h" 3 deque(deque&&) = default; deque(const deque& __x, const allocator_type& __a) : _Base(__a, __x.size()) { std::__uninitialized_copy_a(__x.begin(), __x.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); } deque(deque&& __x, const allocator_type& __a) : deque(std::move(__x), __a, typename _Alloc_traits::is_always_equal{}) { } private: deque(deque&& __x, const allocator_type& __a, true_type) : _Base(std::move(__x), __a) { } deque(deque&& __x, const allocator_type& __a, false_type) : _Base(std::move(__x), __a, __x.size()) { if (__x.get_allocator() != __a && !__x.empty()) { std::__uninitialized_move_a(__x.begin(), __x.end(), this->_M_impl._M_start, _M_get_Tp_allocator()); __x.clear(); } } public: # 952 "/usr/include/c++/10/bits/stl_deque.h" 3 deque(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_range_initialize(__l.begin(), __l.end(), random_access_iterator_tag()); } # 977 "/usr/include/c++/10/bits/stl_deque.h" 3 template> deque(_InputIterator __first, _InputIterator __last, const allocator_type& __a = allocator_type()) : _Base(__a) { _M_range_initialize(__first, __last, std::__iterator_category(__first)); } # 1003 "/usr/include/c++/10/bits/stl_deque.h" 3 ~deque() { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); } # 1015 "/usr/include/c++/10/bits/stl_deque.h" 3 deque& operator=(const deque& __x); # 1027 "/usr/include/c++/10/bits/stl_deque.h" 3 deque& operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal()) { using __always_equal = typename _Alloc_traits::is_always_equal; _M_move_assign1(std::move(__x), __always_equal{}); return *this; } # 1046 "/usr/include/c++/10/bits/stl_deque.h" 3 deque& operator=(initializer_list __l) { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); return *this; } # 1065 "/usr/include/c++/10/bits/stl_deque.h" 3 void assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); } # 1082 "/usr/include/c++/10/bits/stl_deque.h" 3 template> void assign(_InputIterator __first, _InputIterator __last) { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } # 1109 "/usr/include/c++/10/bits/stl_deque.h" 3 void assign(initializer_list __l) { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } allocator_type get_allocator() const noexcept { return _Base::get_allocator(); } iterator begin() noexcept { return this->_M_impl._M_start; } const_iterator begin() const noexcept { return this->_M_impl._M_start; } iterator end() noexcept { return this->_M_impl._M_finish; } const_iterator end() const noexcept { return this->_M_impl._M_finish; } reverse_iterator rbegin() noexcept { return reverse_iterator(this->_M_impl._M_finish); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(this->_M_impl._M_finish); } reverse_iterator rend() noexcept { return reverse_iterator(this->_M_impl._M_start); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(this->_M_impl._M_start); } const_iterator cbegin() const noexcept { return this->_M_impl._M_start; } const_iterator cend() const noexcept { return this->_M_impl._M_finish; } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(this->_M_impl._M_finish); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(this->_M_impl._M_start); } size_type size() const noexcept { return this->_M_impl._M_finish - this->_M_impl._M_start; } size_type max_size() const noexcept { return _S_max_size(_M_get_Tp_allocator()); } # 1248 "/usr/include/c++/10/bits/stl_deque.h" 3 void resize(size_type __new_size) { const size_type __len = size(); if (__new_size > __len) _M_default_append(__new_size - __len); else if (__new_size < __len) _M_erase_at_end(this->_M_impl._M_start + difference_type(__new_size)); } # 1270 "/usr/include/c++/10/bits/stl_deque.h" 3 void resize(size_type __new_size, const value_type& __x) # 1287 "/usr/include/c++/10/bits/stl_deque.h" 3 { const size_type __len = size(); if (__new_size > __len) _M_fill_insert(this->_M_impl._M_finish, __new_size - __len, __x); else if (__new_size < __len) _M_erase_at_end(this->_M_impl._M_start + difference_type(__new_size)); } void shrink_to_fit() noexcept { _M_shrink_to_fit(); } [[__nodiscard__]] bool empty() const noexcept { return this->_M_impl._M_finish == this->_M_impl._M_start; } # 1323 "/usr/include/c++/10/bits/stl_deque.h" 3 reference operator[](size_type __n) noexcept { ; return this->_M_impl._M_start[difference_type(__n)]; } # 1341 "/usr/include/c++/10/bits/stl_deque.h" 3 const_reference operator[](size_type __n) const noexcept { ; return this->_M_impl._M_start[difference_type(__n)]; } protected: void _M_range_check(size_type __n) const { if (__n >= this->size()) __throw_out_of_range_fmt(("deque::_M_range_check: __n " "(which is %zu)>= this->size() " "(which is %zu)") , __n, this->size()); } public: # 1372 "/usr/include/c++/10/bits/stl_deque.h" 3 reference at(size_type __n) { _M_range_check(__n); return (*this)[__n]; } # 1390 "/usr/include/c++/10/bits/stl_deque.h" 3 const_reference at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } reference front() noexcept { ; return *begin(); } const_reference front() const noexcept { ; return *begin(); } reference back() noexcept { ; iterator __tmp = end(); --__tmp; return *__tmp; } const_reference back() const noexcept { ; const_iterator __tmp = end(); --__tmp; return *__tmp; } # 1455 "/usr/include/c++/10/bits/stl_deque.h" 3 void push_front(const value_type& __x) { if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first) { _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_start._M_cur - 1, __x); --this->_M_impl._M_start._M_cur; } else _M_push_front_aux(__x); } void push_front(value_type&& __x) { emplace_front(std::move(__x)); } template reference emplace_front(_Args&&... __args); # 1492 "/usr/include/c++/10/bits/stl_deque.h" 3 void push_back(const value_type& __x) { if (this->_M_impl._M_finish._M_cur != this->_M_impl._M_finish._M_last - 1) { _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish._M_cur, __x); ++this->_M_impl._M_finish._M_cur; } else _M_push_back_aux(__x); } void push_back(value_type&& __x) { emplace_back(std::move(__x)); } template reference emplace_back(_Args&&... __args); # 1528 "/usr/include/c++/10/bits/stl_deque.h" 3 void pop_front() noexcept { ; if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_last - 1) { _Alloc_traits::destroy(_M_get_Tp_allocator(), this->_M_impl._M_start._M_cur); ++this->_M_impl._M_start._M_cur; } else _M_pop_front_aux(); } # 1551 "/usr/include/c++/10/bits/stl_deque.h" 3 void pop_back() noexcept { ; if (this->_M_impl._M_finish._M_cur != this->_M_impl._M_finish._M_first) { --this->_M_impl._M_finish._M_cur; _Alloc_traits::destroy(_M_get_Tp_allocator(), this->_M_impl._M_finish._M_cur); } else _M_pop_back_aux(); } # 1576 "/usr/include/c++/10/bits/stl_deque.h" 3 template iterator emplace(const_iterator __position, _Args&&... __args); # 1589 "/usr/include/c++/10/bits/stl_deque.h" 3 iterator insert(const_iterator __position, const value_type& __x); # 1615 "/usr/include/c++/10/bits/stl_deque.h" 3 iterator insert(const_iterator __position, value_type&& __x) { return emplace(__position, std::move(__x)); } # 1629 "/usr/include/c++/10/bits/stl_deque.h" 3 iterator insert(const_iterator __p, initializer_list __l) { auto __offset = __p - cbegin(); _M_range_insert_aux(__p._M_const_cast(), __l.begin(), __l.end(), std::random_access_iterator_tag()); return begin() + __offset; } # 1648 "/usr/include/c++/10/bits/stl_deque.h" 3 iterator insert(const_iterator __position, size_type __n, const value_type& __x) { difference_type __offset = __position - cbegin(); _M_fill_insert(__position._M_const_cast(), __n, __x); return begin() + __offset; } # 1682 "/usr/include/c++/10/bits/stl_deque.h" 3 template> iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { difference_type __offset = __position - cbegin(); _M_range_insert_aux(__position._M_const_cast(), __first, __last, std::__iterator_category(__first)); return begin() + __offset; } # 1728 "/usr/include/c++/10/bits/stl_deque.h" 3 iterator erase(const_iterator __position) { return _M_erase(__position._M_const_cast()); } # 1752 "/usr/include/c++/10/bits/stl_deque.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } # 1771 "/usr/include/c++/10/bits/stl_deque.h" 3 void swap(deque& __x) noexcept { ; _M_impl._M_swap_data(__x._M_impl); _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } void clear() noexcept { _M_erase_at_end(begin()); } protected: # 1821 "/usr/include/c++/10/bits/stl_deque.h" 3 static size_t _S_check_init_len(size_t __n, const allocator_type& __a) { if (__n > _S_max_size(__a)) __throw_length_error( ("cannot create std::deque larger than max_size()")); return __n; } static size_type _S_max_size(const _Tp_alloc_type& __a) noexcept { const size_t __diffmax = __gnu_cxx::__numeric_traits::__max; const size_t __allocmax = _Alloc_traits::max_size(__a); return (std::min)(__diffmax, __allocmax); } # 1850 "/usr/include/c++/10/bits/stl_deque.h" 3 template void _M_range_initialize(_InputIterator __first, _InputIterator __last, std::input_iterator_tag); template void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); # 1872 "/usr/include/c++/10/bits/stl_deque.h" 3 void _M_fill_initialize(const value_type& __value); void _M_default_initialize(); # 1903 "/usr/include/c++/10/bits/stl_deque.h" 3 template void _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag); template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __len = std::distance(__first, __last); if (__len > size()) { _ForwardIterator __mid = __first; std::advance(__mid, size()); std::copy(__first, __mid, begin()); _M_range_insert_aux(end(), __mid, __last, std::__iterator_category(__first)); } else _M_erase_at_end(std::copy(__first, __last, begin())); } void _M_fill_assign(size_type __n, const value_type& __val) { if (__n > size()) { std::fill(begin(), end(), __val); _M_fill_insert(end(), __n - size(), __val); } else { _M_erase_at_end(begin() + difference_type(__n)); std::fill(begin(), end(), __val); } } # 1951 "/usr/include/c++/10/bits/stl_deque.h" 3 template void _M_push_back_aux(_Args&&... __args); template void _M_push_front_aux(_Args&&... __args); void _M_pop_back_aux(); void _M_pop_front_aux(); # 1990 "/usr/include/c++/10/bits/stl_deque.h" 3 template void _M_range_insert_aux(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag); template void _M_range_insert_aux(iterator __pos, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag); void _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); template iterator _M_insert_aux(iterator __pos, _Args&&... __args); void _M_insert_aux(iterator __pos, size_type __n, const value_type& __x); template void _M_insert_aux(iterator __pos, _ForwardIterator __first, _ForwardIterator __last, size_type __n); void _M_destroy_data_aux(iterator __first, iterator __last); template void _M_destroy_data(iterator __first, iterator __last, const _Alloc1&) { _M_destroy_data_aux(__first, __last); } void _M_destroy_data(iterator __first, iterator __last, const std::allocator<_Tp>&) { if (!__has_trivial_destructor(value_type)) _M_destroy_data_aux(__first, __last); } void _M_erase_at_begin(iterator __pos) { _M_destroy_data(begin(), __pos, _M_get_Tp_allocator()); _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node); this->_M_impl._M_start = __pos; } void _M_erase_at_end(iterator __pos) { _M_destroy_data(__pos, end(), _M_get_Tp_allocator()); _M_destroy_nodes(__pos._M_node + 1, this->_M_impl._M_finish._M_node + 1); this->_M_impl._M_finish = __pos; } iterator _M_erase(iterator __pos); iterator _M_erase(iterator __first, iterator __last); void _M_default_append(size_type __n); bool _M_shrink_to_fit(); iterator _M_reserve_elements_at_front(size_type __n) { const size_type __vacancies = this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first; if (__n > __vacancies) _M_new_elements_at_front(__n - __vacancies); return this->_M_impl._M_start - difference_type(__n); } iterator _M_reserve_elements_at_back(size_type __n) { const size_type __vacancies = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur) - 1; if (__n > __vacancies) _M_new_elements_at_back(__n - __vacancies); return this->_M_impl._M_finish + difference_type(__n); } void _M_new_elements_at_front(size_type __new_elements); void _M_new_elements_at_back(size_type __new_elements); # 2122 "/usr/include/c++/10/bits/stl_deque.h" 3 void _M_reserve_map_at_back(size_type __nodes_to_add = 1) { if (__nodes_to_add + 1 > this->_M_impl._M_map_size - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map)) _M_reallocate_map(__nodes_to_add, false); } void _M_reserve_map_at_front(size_type __nodes_to_add = 1) { if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node - this->_M_impl._M_map)) _M_reallocate_map(__nodes_to_add, true); } void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front); void _M_move_assign1(deque&& __x, true_type) noexcept { this->_M_impl._M_swap_data(__x._M_impl); __x.clear(); std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } void _M_move_assign1(deque&& __x, false_type) { constexpr bool __move_storage = _Alloc_traits::_S_propagate_on_move_assign(); _M_move_assign2(std::move(__x), __bool_constant<__move_storage>()); } template void _M_replace_map(_Args&&... __args) { deque __newobj(std::forward<_Args>(__args)...); clear(); _M_deallocate_node(*begin()._M_node); _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); this->_M_impl._M_map = nullptr; this->_M_impl._M_map_size = 0; this->_M_impl._M_swap_data(__newobj._M_impl); } void _M_move_assign2(deque&& __x, true_type) { auto __alloc = __x._M_get_Tp_allocator(); _M_replace_map(std::move(__x)); _M_get_Tp_allocator() = std::move(__alloc); } void _M_move_assign2(deque&& __x, false_type) { if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) { _M_replace_map(std::move(__x), __x.get_allocator()); } else { _M_assign_aux(std::make_move_iterator(__x.begin()), std::make_move_iterator(__x.end()), std::random_access_iterator_tag()); __x.clear(); } } }; template::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>> deque(_InputIterator, _InputIterator, _Allocator = _Allocator()) -> deque<_ValT, _Allocator>; # 2239 "/usr/include/c++/10/bits/stl_deque.h" 3 template inline bool operator==(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y) { return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } # 2257 "/usr/include/c++/10/bits/stl_deque.h" 3 template inline __detail::__synth3way_t<_Tp> operator<=>(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y) { return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __detail::__synth3way); } # 2309 "/usr/include/c++/10/bits/stl_deque.h" 3 template inline void swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct __is_bitwise_relocatable> : true_type { }; } # 68 "/usr/include/c++/10/deque" 2 3 # 1 "/usr/include/c++/10/bits/deque.tcc" 1 3 # 61 "/usr/include/c++/10/bits/deque.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template void deque<_Tp, _Alloc>:: _M_default_initialize() { _Map_pointer __cur; try { for (__cur = this->_M_impl._M_start._M_node; __cur < this->_M_impl._M_finish._M_node; ++__cur) std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(), _M_get_Tp_allocator()); std::__uninitialized_default_a(this->_M_impl._M_finish._M_first, this->_M_impl._M_finish._M_cur, _M_get_Tp_allocator()); } catch(...) { std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur), _M_get_Tp_allocator()); throw; } } template deque<_Tp, _Alloc>& deque<_Tp, _Alloc>:: operator=(const deque& __x) { if (&__x != this) { if (_Alloc_traits::_S_propagate_on_copy_assign()) { if (!_Alloc_traits::_S_always_equal() && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) { _M_replace_map(__x, __x.get_allocator()); std::__alloc_on_copy(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); return *this; } std::__alloc_on_copy(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); } const size_type __len = size(); if (__len >= __x.size()) _M_erase_at_end(std::copy(__x.begin(), __x.end(), this->_M_impl._M_start)); else { const_iterator __mid = __x.begin() + difference_type(__len); std::copy(__x.begin(), __mid, this->_M_impl._M_start); _M_range_insert_aux(this->_M_impl._M_finish, __mid, __x.end(), std::random_access_iterator_tag()); } } return *this; } template template typename deque<_Tp, _Alloc>::reference deque<_Tp, _Alloc>:: emplace_front(_Args&&... __args) { if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first) { _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_start._M_cur - 1, std::forward<_Args>(__args)...); --this->_M_impl._M_start._M_cur; } else _M_push_front_aux(std::forward<_Args>(__args)...); return front(); } template template typename deque<_Tp, _Alloc>::reference deque<_Tp, _Alloc>:: emplace_back(_Args&&... __args) { if (this->_M_impl._M_finish._M_cur != this->_M_impl._M_finish._M_last - 1) { _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish._M_cur, std::forward<_Args>(__args)...); ++this->_M_impl._M_finish._M_cur; } else _M_push_back_aux(std::forward<_Args>(__args)...); return back(); } template template typename deque<_Tp, _Alloc>::iterator deque<_Tp, _Alloc>:: emplace(const_iterator __position, _Args&&... __args) { if (__position._M_cur == this->_M_impl._M_start._M_cur) { emplace_front(std::forward<_Args>(__args)...); return this->_M_impl._M_start; } else if (__position._M_cur == this->_M_impl._M_finish._M_cur) { emplace_back(std::forward<_Args>(__args)...); iterator __tmp = this->_M_impl._M_finish; --__tmp; return __tmp; } else return _M_insert_aux(__position._M_const_cast(), std::forward<_Args>(__args)...); } template typename deque<_Tp, _Alloc>::iterator deque<_Tp, _Alloc>:: insert(const_iterator __position, const value_type& __x) { if (__position._M_cur == this->_M_impl._M_start._M_cur) { push_front(__x); return this->_M_impl._M_start; } else if (__position._M_cur == this->_M_impl._M_finish._M_cur) { push_back(__x); iterator __tmp = this->_M_impl._M_finish; --__tmp; return __tmp; } else return _M_insert_aux(__position._M_const_cast(), __x); } template typename deque<_Tp, _Alloc>::iterator deque<_Tp, _Alloc>:: _M_erase(iterator __position) { iterator __next = __position; ++__next; const difference_type __index = __position - begin(); if (static_cast(__index) < (size() >> 1)) { if (__position != begin()) std::move_backward(begin(), __position, __next); pop_front(); } else { if (__next != end()) std::move(__next, end(), __position); pop_back(); } return begin() + __index; } template typename deque<_Tp, _Alloc>::iterator deque<_Tp, _Alloc>:: _M_erase(iterator __first, iterator __last) { if (__first == __last) return __first; else if (__first == begin() && __last == end()) { clear(); return end(); } else { const difference_type __n = __last - __first; const difference_type __elems_before = __first - begin(); if (static_cast(__elems_before) <= (size() - __n) / 2) { if (__first != begin()) std::move_backward(begin(), __first, __last); _M_erase_at_begin(begin() + __n); } else { if (__last != end()) std::move(__last, end(), __first); _M_erase_at_end(end() - __n); } return begin() + __elems_before; } } template template void deque<_Tp, _Alloc>:: _M_assign_aux(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { iterator __cur = begin(); for (; __first != __last && __cur != end(); ++__cur, (void)++__first) *__cur = *__first; if (__first == __last) _M_erase_at_end(__cur); else _M_range_insert_aux(end(), __first, __last, std::__iterator_category(__first)); } template void deque<_Tp, _Alloc>:: _M_fill_insert(iterator __pos, size_type __n, const value_type& __x) { if (__pos._M_cur == this->_M_impl._M_start._M_cur) { iterator __new_start = _M_reserve_elements_at_front(__n); try { std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start, __x, _M_get_Tp_allocator()); this->_M_impl._M_start = __new_start; } catch(...) { _M_destroy_nodes(__new_start._M_node, this->_M_impl._M_start._M_node); throw; } } else if (__pos._M_cur == this->_M_impl._M_finish._M_cur) { iterator __new_finish = _M_reserve_elements_at_back(__n); try { std::__uninitialized_fill_a(this->_M_impl._M_finish, __new_finish, __x, _M_get_Tp_allocator()); this->_M_impl._M_finish = __new_finish; } catch(...) { _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, __new_finish._M_node + 1); throw; } } else _M_insert_aux(__pos, __n, __x); } template void deque<_Tp, _Alloc>:: _M_default_append(size_type __n) { if (__n) { iterator __new_finish = _M_reserve_elements_at_back(__n); try { std::__uninitialized_default_a(this->_M_impl._M_finish, __new_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __new_finish; } catch(...) { _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, __new_finish._M_node + 1); throw; } } } template bool deque<_Tp, _Alloc>:: _M_shrink_to_fit() { const difference_type __front_capacity = (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first); if (__front_capacity == 0) return false; const difference_type __back_capacity = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur); if (__front_capacity + __back_capacity < _S_buffer_size()) return false; return std::__shrink_to_fit_aux::_S_do_it(*this); } template void deque<_Tp, _Alloc>:: _M_fill_initialize(const value_type& __value) { _Map_pointer __cur; try { for (__cur = this->_M_impl._M_start._M_node; __cur < this->_M_impl._M_finish._M_node; ++__cur) std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(), __value, _M_get_Tp_allocator()); std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first, this->_M_impl._M_finish._M_cur, __value, _M_get_Tp_allocator()); } catch(...) { std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur), _M_get_Tp_allocator()); throw; } } template template void deque<_Tp, _Alloc>:: _M_range_initialize(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) { this->_M_initialize_map(0); try { for (; __first != __last; ++__first) emplace_back(*__first); } catch(...) { clear(); throw; } } template template void deque<_Tp, _Alloc>:: _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); this->_M_initialize_map(_S_check_init_len(__n, _M_get_Tp_allocator())); _Map_pointer __cur_node; try { for (__cur_node = this->_M_impl._M_start._M_node; __cur_node < this->_M_impl._M_finish._M_node; ++__cur_node) { _ForwardIterator __mid = __first; std::advance(__mid, _S_buffer_size()); std::__uninitialized_copy_a(__first, __mid, *__cur_node, _M_get_Tp_allocator()); __first = __mid; } std::__uninitialized_copy_a(__first, __last, this->_M_impl._M_finish._M_first, _M_get_Tp_allocator()); } catch(...) { std::_Destroy(this->_M_impl._M_start, iterator(*__cur_node, __cur_node), _M_get_Tp_allocator()); throw; } } template template void deque<_Tp, _Alloc>:: _M_push_back_aux(_Args&&... __args) { if (size() == max_size()) __throw_length_error( ("cannot create std::deque larger than max_size()")); _M_reserve_map_at_back(); *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node(); try { _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish._M_cur, std::forward<_Args>(__args)...); this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node + 1); this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first; } catch(...) { _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1)); throw; } } template template void deque<_Tp, _Alloc>:: _M_push_front_aux(_Args&&... __args) { if (size() == max_size()) __throw_length_error( ("cannot create std::deque larger than max_size()")); _M_reserve_map_at_front(); *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node(); try { this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node - 1); this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1; _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_start._M_cur, std::forward<_Args>(__args)...); } catch(...) { ++this->_M_impl._M_start; _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1)); throw; } } template void deque<_Tp, _Alloc>:: _M_pop_back_aux() { _M_deallocate_node(this->_M_impl._M_finish._M_first); this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1); this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1; _Alloc_traits::destroy(_M_get_Tp_allocator(), this->_M_impl._M_finish._M_cur); } template void deque<_Tp, _Alloc>:: _M_pop_front_aux() { _Alloc_traits::destroy(_M_get_Tp_allocator(), this->_M_impl._M_start._M_cur); _M_deallocate_node(this->_M_impl._M_start._M_first); this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1); this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first; } template template void deque<_Tp, _Alloc>:: _M_range_insert_aux(iterator __pos, _InputIterator __first, _InputIterator __last, std::input_iterator_tag) { std::copy(__first, __last, std::inserter(*this, __pos)); } template template void deque<_Tp, _Alloc>:: _M_range_insert_aux(iterator __pos, _ForwardIterator __first, _ForwardIterator __last, std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); if (__pos._M_cur == this->_M_impl._M_start._M_cur) { iterator __new_start = _M_reserve_elements_at_front(__n); try { std::__uninitialized_copy_a(__first, __last, __new_start, _M_get_Tp_allocator()); this->_M_impl._M_start = __new_start; } catch(...) { _M_destroy_nodes(__new_start._M_node, this->_M_impl._M_start._M_node); throw; } } else if (__pos._M_cur == this->_M_impl._M_finish._M_cur) { iterator __new_finish = _M_reserve_elements_at_back(__n); try { std::__uninitialized_copy_a(__first, __last, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __new_finish; } catch(...) { _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, __new_finish._M_node + 1); throw; } } else _M_insert_aux(__pos, __first, __last, __n); } template template typename deque<_Tp, _Alloc>::iterator deque<_Tp, _Alloc>:: _M_insert_aux(iterator __pos, _Args&&... __args) { value_type __x_copy(std::forward<_Args>(__args)...); difference_type __index = __pos - this->_M_impl._M_start; if (static_cast(__index) < size() / 2) { push_front(std::move(front())); iterator __front1 = this->_M_impl._M_start; ++__front1; iterator __front2 = __front1; ++__front2; __pos = this->_M_impl._M_start + __index; iterator __pos1 = __pos; ++__pos1; std::move(__front2, __pos1, __front1); } else { push_back(std::move(back())); iterator __back1 = this->_M_impl._M_finish; --__back1; iterator __back2 = __back1; --__back2; __pos = this->_M_impl._M_start + __index; std::move_backward(__pos, __back2, __back1); } *__pos = std::move(__x_copy); return __pos; } template void deque<_Tp, _Alloc>:: _M_insert_aux(iterator __pos, size_type __n, const value_type& __x) { const difference_type __elems_before = __pos - this->_M_impl._M_start; const size_type __length = this->size(); value_type __x_copy = __x; if (__elems_before < difference_type(__length / 2)) { iterator __new_start = _M_reserve_elements_at_front(__n); iterator __old_start = this->_M_impl._M_start; __pos = this->_M_impl._M_start + __elems_before; try { if (__elems_before >= difference_type(__n)) { iterator __start_n = (this->_M_impl._M_start + difference_type(__n)); std::__uninitialized_move_a(this->_M_impl._M_start, __start_n, __new_start, _M_get_Tp_allocator()); this->_M_impl._M_start = __new_start; std::move(__start_n, __pos, __old_start); std::fill(__pos - difference_type(__n), __pos, __x_copy); } else { std::__uninitialized_move_fill(this->_M_impl._M_start, __pos, __new_start, this->_M_impl._M_start, __x_copy, _M_get_Tp_allocator()); this->_M_impl._M_start = __new_start; std::fill(__old_start, __pos, __x_copy); } } catch(...) { _M_destroy_nodes(__new_start._M_node, this->_M_impl._M_start._M_node); throw; } } else { iterator __new_finish = _M_reserve_elements_at_back(__n); iterator __old_finish = this->_M_impl._M_finish; const difference_type __elems_after = difference_type(__length) - __elems_before; __pos = this->_M_impl._M_finish - __elems_after; try { if (__elems_after > difference_type(__n)) { iterator __finish_n = (this->_M_impl._M_finish - difference_type(__n)); std::__uninitialized_move_a(__finish_n, this->_M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __new_finish; std::move_backward(__pos, __finish_n, __old_finish); std::fill(__pos, __pos + difference_type(__n), __x_copy); } else { std::__uninitialized_fill_move(this->_M_impl._M_finish, __pos + difference_type(__n), __x_copy, __pos, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __new_finish; std::fill(__pos, __old_finish, __x_copy); } } catch(...) { _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, __new_finish._M_node + 1); throw; } } } template template void deque<_Tp, _Alloc>:: _M_insert_aux(iterator __pos, _ForwardIterator __first, _ForwardIterator __last, size_type __n) { const difference_type __elemsbefore = __pos - this->_M_impl._M_start; const size_type __length = size(); if (static_cast(__elemsbefore) < __length / 2) { iterator __new_start = _M_reserve_elements_at_front(__n); iterator __old_start = this->_M_impl._M_start; __pos = this->_M_impl._M_start + __elemsbefore; try { if (__elemsbefore >= difference_type(__n)) { iterator __start_n = (this->_M_impl._M_start + difference_type(__n)); std::__uninitialized_move_a(this->_M_impl._M_start, __start_n, __new_start, _M_get_Tp_allocator()); this->_M_impl._M_start = __new_start; std::move(__start_n, __pos, __old_start); std::copy(__first, __last, __pos - difference_type(__n)); } else { _ForwardIterator __mid = __first; std::advance(__mid, difference_type(__n) - __elemsbefore); std::__uninitialized_move_copy(this->_M_impl._M_start, __pos, __first, __mid, __new_start, _M_get_Tp_allocator()); this->_M_impl._M_start = __new_start; std::copy(__mid, __last, __old_start); } } catch(...) { _M_destroy_nodes(__new_start._M_node, this->_M_impl._M_start._M_node); throw; } } else { iterator __new_finish = _M_reserve_elements_at_back(__n); iterator __old_finish = this->_M_impl._M_finish; const difference_type __elemsafter = difference_type(__length) - __elemsbefore; __pos = this->_M_impl._M_finish - __elemsafter; try { if (__elemsafter > difference_type(__n)) { iterator __finish_n = (this->_M_impl._M_finish - difference_type(__n)); std::__uninitialized_move_a(__finish_n, this->_M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __new_finish; std::move_backward(__pos, __finish_n, __old_finish); std::copy(__first, __last, __pos); } else { _ForwardIterator __mid = __first; std::advance(__mid, __elemsafter); std::__uninitialized_copy_move(__mid, __last, __pos, this->_M_impl._M_finish, this->_M_impl._M_finish, _M_get_Tp_allocator()); this->_M_impl._M_finish = __new_finish; std::copy(__first, __mid, __pos); } } catch(...) { _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, __new_finish._M_node + 1); throw; } } } template void deque<_Tp, _Alloc>:: _M_destroy_data_aux(iterator __first, iterator __last) { for (_Map_pointer __node = __first._M_node + 1; __node < __last._M_node; ++__node) std::_Destroy(*__node, *__node + _S_buffer_size(), _M_get_Tp_allocator()); if (__first._M_node != __last._M_node) { std::_Destroy(__first._M_cur, __first._M_last, _M_get_Tp_allocator()); std::_Destroy(__last._M_first, __last._M_cur, _M_get_Tp_allocator()); } else std::_Destroy(__first._M_cur, __last._M_cur, _M_get_Tp_allocator()); } template void deque<_Tp, _Alloc>:: _M_new_elements_at_front(size_type __new_elems) { if (this->max_size() - this->size() < __new_elems) __throw_length_error(("deque::_M_new_elements_at_front")); const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1) / _S_buffer_size()); _M_reserve_map_at_front(__new_nodes); size_type __i; try { for (__i = 1; __i <= __new_nodes; ++__i) *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node(); } catch(...) { for (size_type __j = 1; __j < __i; ++__j) _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j)); throw; } } template void deque<_Tp, _Alloc>:: _M_new_elements_at_back(size_type __new_elems) { if (this->max_size() - this->size() < __new_elems) __throw_length_error(("deque::_M_new_elements_at_back")); const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1) / _S_buffer_size()); _M_reserve_map_at_back(__new_nodes); size_type __i; try { for (__i = 1; __i <= __new_nodes; ++__i) *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node(); } catch(...) { for (size_type __j = 1; __j < __i; ++__j) _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j)); throw; } } template void deque<_Tp, _Alloc>:: _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front) { const size_type __old_num_nodes = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1; const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add; _Map_pointer __new_nstart; if (this->_M_impl._M_map_size > 2 * __new_num_nodes) { __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size - __new_num_nodes) / 2 + (__add_at_front ? __nodes_to_add : 0); if (__new_nstart < this->_M_impl._M_start._M_node) std::copy(this->_M_impl._M_start._M_node, this->_M_impl._M_finish._M_node + 1, __new_nstart); else std::copy_backward(this->_M_impl._M_start._M_node, this->_M_impl._M_finish._M_node + 1, __new_nstart + __old_num_nodes); } else { size_type __new_map_size = this->_M_impl._M_map_size + std::max(this->_M_impl._M_map_size, __nodes_to_add) + 2; _Map_pointer __new_map = this->_M_allocate_map(__new_map_size); __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2 + (__add_at_front ? __nodes_to_add : 0); std::copy(this->_M_impl._M_start._M_node, this->_M_impl._M_finish._M_node + 1, __new_nstart); _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); this->_M_impl._M_map = __new_map; this->_M_impl._M_map_size = __new_map_size; } this->_M_impl._M_start._M_set_node(__new_nstart); this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); } template void __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>& __first, const std::_Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _VTp& __value) { typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter; if (__first._M_node != __last._M_node) { std::__fill_a1(__first._M_cur, __first._M_last, __value); for (typename _Iter::_Map_pointer __node = __first._M_node + 1; __node < __last._M_node; ++__node) std::__fill_a1(*__node, *__node + _Iter::_S_buffer_size(), __value); std::__fill_a1(__last._M_first, __last._M_cur, __value); } else std::__fill_a1(__first._M_cur, __last._M_cur, __value); } template _OI __copy_move_dit(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first, std::_Deque_iterator<_Tp, _Ref, _Ptr> __last, _OI __result) { typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter; if (__first._M_node != __last._M_node) { __result = std::__copy_move_a1<_IsMove>(__first._M_cur, __first._M_last, __result); for (typename _Iter::_Map_pointer __node = __first._M_node + 1; __node != __last._M_node; ++__node) __result = std::__copy_move_a1<_IsMove>(*__node, *__node + _Iter::_S_buffer_size(), __result); return std::__copy_move_a1<_IsMove>(__last._M_first, __last._M_cur, __result); } return std::__copy_move_a1<_IsMove>(__first._M_cur, __last._M_cur, __result); } template _OI __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first, std::_Deque_iterator<_Tp, _Ref, _Ptr> __last, _OI __result) { return __copy_move_dit<_IsMove>(__first, __last, __result); } template std::_Deque_iterator<_OTp, _OTp&, _OTp*> __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr> __first, std::_Deque_iterator<_ITp, _IRef, _IPtr> __last, std::_Deque_iterator<_OTp, _OTp&, _OTp*> __result) { return __copy_move_dit<_IsMove>(__first, __last, __result); } template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __copy_move_a1(_II __first, _II __last, std::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) { typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter; typedef typename _Iter::difference_type difference_type; difference_type __len = __last - __first; while (__len > 0) { const difference_type __clen = std::min(__len, __result._M_last - __result._M_cur); std::__copy_move_a1<_IsMove>(__first, __first + __clen, __result._M_cur); __first += __clen; __result += __clen; __len -= __clen; } return __result; } template _OI __copy_move_backward_dit( std::_Deque_iterator<_Tp, _Ref, _Ptr> __first, std::_Deque_iterator<_Tp, _Ref, _Ptr> __last, _OI __result) { typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter; if (__first._M_node != __last._M_node) { __result = std::__copy_move_backward_a1<_IsMove>( __last._M_first, __last._M_cur, __result); for (typename _Iter::_Map_pointer __node = __last._M_node - 1; __node != __first._M_node; --__node) __result = std::__copy_move_backward_a1<_IsMove>( *__node, *__node + _Iter::_S_buffer_size(), __result); return std::__copy_move_backward_a1<_IsMove>( __first._M_cur, __first._M_last, __result); } return std::__copy_move_backward_a1<_IsMove>( __first._M_cur, __last._M_cur, __result); } template _OI __copy_move_backward_a1( std::_Deque_iterator<_Tp, _Ref, _Ptr> __first, std::_Deque_iterator<_Tp, _Ref, _Ptr> __last, _OI __result) { return __copy_move_backward_dit<_IsMove>(__first, __last, __result); } template std::_Deque_iterator<_OTp, _OTp&, _OTp*> __copy_move_backward_a1( std::_Deque_iterator<_ITp, _IRef, _IPtr> __first, std::_Deque_iterator<_ITp, _IRef, _IPtr> __last, std::_Deque_iterator<_OTp, _OTp&, _OTp*> __result) { return __copy_move_backward_dit<_IsMove>(__first, __last, __result); } template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type __copy_move_backward_a1(_II __first, _II __last, std::_Deque_iterator<_Tp, _Tp&, _Tp*> __result) { typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter; typedef typename _Iter::difference_type difference_type; difference_type __len = __last - __first; while (__len > 0) { difference_type __rlen = __result._M_cur - __result._M_first; _Tp* __rend = __result._M_cur; if (!__rlen) { __rlen = _Iter::_S_buffer_size(); __rend = *(__result._M_node - 1) + __rlen; } const difference_type __clen = std::min(__len, __rlen); std::__copy_move_backward_a1<_IsMove>(__last - __clen, __last, __rend); __last -= __clen; __result -= __clen; __len -= __clen; } return __result; } template bool __equal_dit( const std::_Deque_iterator<_Tp, _Ref, _Ptr>& __first1, const std::_Deque_iterator<_Tp, _Ref, _Ptr>& __last1, _II __first2) { typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter; if (__first1._M_node != __last1._M_node) { if (!std::__equal_aux1(__first1._M_cur, __first1._M_last, __first2)) return false; __first2 += __first1._M_last - __first1._M_cur; for (typename _Iter::_Map_pointer __node = __first1._M_node + 1; __node != __last1._M_node; __first2 += _Iter::_S_buffer_size(), ++__node) if (!std::__equal_aux1(*__node, *__node + _Iter::_S_buffer_size(), __first2)) return false; return std::__equal_aux1(__last1._M_first, __last1._M_cur, __first2); } return std::__equal_aux1(__first1._M_cur, __last1._M_cur, __first2); } template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, bool>::__type __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first1, std::_Deque_iterator<_Tp, _Ref, _Ptr> __last1, _II __first2) { return std::__equal_dit(__first1, __last1, __first2); } template bool __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1, std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1, std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2) { return std::__equal_dit(__first1, __last1, __first2); } template typename __gnu_cxx::__enable_if< __is_random_access_iter<_II>::__value, bool>::__type __equal_aux1(_II __first1, _II __last1, std::_Deque_iterator<_Tp, _Ref, _Ptr> __first2) { typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter; typedef typename _Iter::difference_type difference_type; difference_type __len = __last1 - __first1; while (__len > 0) { const difference_type __clen = std::min(__len, __first2._M_last - __first2._M_cur); if (!std::__equal_aux1(__first1, __first1 + __clen, __first2._M_cur)) return false; __first1 += __clen; __len -= __clen; __first2 += __clen; } return true; } } # 70 "/usr/include/c++/10/deque" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template using deque = std::deque<_Tp, polymorphic_allocator<_Tp>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename deque<_Tp, _Alloc>::size_type erase_if(deque<_Tp, _Alloc>& __cont, _Predicate __pred) { const auto __osz = __cont.size(); __cont.erase(std::remove_if(__cont.begin(), __cont.end(), __pred), __cont.end()); return __osz - __cont.size(); } template inline typename deque<_Tp, _Alloc>::size_type erase(deque<_Tp, _Alloc>& __cont, const _Up& __value) { const auto __osz = __cont.size(); __cont.erase(std::remove(__cont.begin(), __cont.end(), __value), __cont.end()); return __osz - __cont.size(); } } # 57 "all-std.cxx" 2 # 1 "/usr/include/c++/10/forward_list" 1 3 # 32 "/usr/include/c++/10/forward_list" 3 # 33 "/usr/include/c++/10/forward_list" 3 # 1 "/usr/include/c++/10/bits/forward_list.h" 1 3 # 33 "/usr/include/c++/10/bits/forward_list.h" 3 # 34 "/usr/include/c++/10/bits/forward_list.h" 3 # 44 "/usr/include/c++/10/bits/forward_list.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct _Fwd_list_node_base { _Fwd_list_node_base() = default; _Fwd_list_node_base(_Fwd_list_node_base&& __x) noexcept : _M_next(__x._M_next) { __x._M_next = nullptr; } _Fwd_list_node_base(const _Fwd_list_node_base&) = delete; _Fwd_list_node_base& operator=(const _Fwd_list_node_base&) = delete; _Fwd_list_node_base& operator=(_Fwd_list_node_base&& __x) noexcept { _M_next = __x._M_next; __x._M_next = nullptr; return *this; } _Fwd_list_node_base* _M_next = nullptr; _Fwd_list_node_base* _M_transfer_after(_Fwd_list_node_base* __begin, _Fwd_list_node_base* __end) noexcept { _Fwd_list_node_base* __keep = __begin->_M_next; if (__end) { __begin->_M_next = __end->_M_next; __end->_M_next = _M_next; } else __begin->_M_next = nullptr; _M_next = __keep; return __end; } void _M_reverse_after() noexcept { _Fwd_list_node_base* __tail = _M_next; if (!__tail) return; while (_Fwd_list_node_base* __temp = __tail->_M_next) { _Fwd_list_node_base* __keep = _M_next; _M_next = __temp; __tail->_M_next = __temp->_M_next; _M_next->_M_next = __keep; } } }; template struct _Fwd_list_node : public _Fwd_list_node_base { _Fwd_list_node() = default; __gnu_cxx::__aligned_buffer<_Tp> _M_storage; _Tp* _M_valptr() noexcept { return _M_storage._M_ptr(); } const _Tp* _M_valptr() const noexcept { return _M_storage._M_ptr(); } }; template struct _Fwd_list_iterator { typedef _Fwd_list_iterator<_Tp> _Self; typedef _Fwd_list_node<_Tp> _Node; typedef _Tp value_type; typedef _Tp* pointer; typedef _Tp& reference; typedef ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Fwd_list_iterator() noexcept : _M_node() { } explicit _Fwd_list_iterator(_Fwd_list_node_base* __n) noexcept : _M_node(__n) { } reference operator*() const noexcept { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); } pointer operator->() const noexcept { return static_cast<_Node*>(this->_M_node)->_M_valptr(); } _Self& operator++() noexcept { _M_node = _M_node->_M_next; return *this; } _Self operator++(int) noexcept { _Self __tmp(*this); _M_node = _M_node->_M_next; return __tmp; } friend bool operator==(const _Self& __x, const _Self& __y) noexcept { return __x._M_node == __y._M_node; } # 192 "/usr/include/c++/10/bits/forward_list.h" 3 _Self _M_next() const noexcept { if (_M_node) return _Fwd_list_iterator(_M_node->_M_next); else return _Fwd_list_iterator(nullptr); } _Fwd_list_node_base* _M_node; }; template struct _Fwd_list_const_iterator { typedef _Fwd_list_const_iterator<_Tp> _Self; typedef const _Fwd_list_node<_Tp> _Node; typedef _Fwd_list_iterator<_Tp> iterator; typedef _Tp value_type; typedef const _Tp* pointer; typedef const _Tp& reference; typedef ptrdiff_t difference_type; typedef std::forward_iterator_tag iterator_category; _Fwd_list_const_iterator() noexcept : _M_node() { } explicit _Fwd_list_const_iterator(const _Fwd_list_node_base* __n) noexcept : _M_node(__n) { } _Fwd_list_const_iterator(const iterator& __iter) noexcept : _M_node(__iter._M_node) { } reference operator*() const noexcept { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); } pointer operator->() const noexcept { return static_cast<_Node*>(this->_M_node)->_M_valptr(); } _Self& operator++() noexcept { _M_node = _M_node->_M_next; return *this; } _Self operator++(int) noexcept { _Self __tmp(*this); _M_node = _M_node->_M_next; return __tmp; } friend bool operator==(const _Self& __x, const _Self& __y) noexcept { return __x._M_node == __y._M_node; } # 271 "/usr/include/c++/10/bits/forward_list.h" 3 _Self _M_next() const noexcept { if (this->_M_node) return _Fwd_list_const_iterator(_M_node->_M_next); else return _Fwd_list_const_iterator(nullptr); } const _Fwd_list_node_base* _M_node; }; template struct _Fwd_list_base { protected: typedef __alloc_rebind<_Alloc, _Fwd_list_node<_Tp>> _Node_alloc_type; typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits; struct _Fwd_list_impl : public _Node_alloc_type { _Fwd_list_node_base _M_head; _Fwd_list_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value) : _Node_alloc_type(), _M_head() { } _Fwd_list_impl(_Fwd_list_impl&&) = default; _Fwd_list_impl(_Fwd_list_impl&& __fl, _Node_alloc_type&& __a) : _Node_alloc_type(std::move(__a)), _M_head(std::move(__fl._M_head)) { } _Fwd_list_impl(_Node_alloc_type&& __a) : _Node_alloc_type(std::move(__a)), _M_head() { } }; _Fwd_list_impl _M_impl; public: typedef _Fwd_list_iterator<_Tp> iterator; typedef _Fwd_list_const_iterator<_Tp> const_iterator; typedef _Fwd_list_node<_Tp> _Node; _Node_alloc_type& _M_get_Node_allocator() noexcept { return this->_M_impl; } const _Node_alloc_type& _M_get_Node_allocator() const noexcept { return this->_M_impl; } _Fwd_list_base() = default; _Fwd_list_base(_Node_alloc_type&& __a) : _M_impl(std::move(__a)) { } _Fwd_list_base(_Fwd_list_base&& __lst, _Node_alloc_type&& __a, std::true_type) : _M_impl(std::move(__lst._M_impl), std::move(__a)) { } _Fwd_list_base(_Fwd_list_base&& __lst, _Node_alloc_type&& __a); _Fwd_list_base(_Fwd_list_base&&) = default; ~_Fwd_list_base() { _M_erase_after(&_M_impl._M_head, nullptr); } protected: _Node* _M_get_node() { auto __ptr = _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1); return std::__to_address(__ptr); } template _Node* _M_create_node(_Args&&... __args) { _Node* __node = this->_M_get_node(); try { ::new ((void*)__node) _Node; _Node_alloc_traits::construct(_M_get_Node_allocator(), __node->_M_valptr(), std::forward<_Args>(__args)...); } catch(...) { this->_M_put_node(__node); throw; } return __node; } template _Fwd_list_node_base* _M_insert_after(const_iterator __pos, _Args&&... __args); void _M_put_node(_Node* __p) { typedef typename _Node_alloc_traits::pointer _Ptr; auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__p); _Node_alloc_traits::deallocate(_M_get_Node_allocator(), __ptr, 1); } _Fwd_list_node_base* _M_erase_after(_Fwd_list_node_base* __pos); _Fwd_list_node_base* _M_erase_after(_Fwd_list_node_base* __pos, _Fwd_list_node_base* __last); }; # 422 "/usr/include/c++/10/bits/forward_list.h" 3 template> class forward_list : private _Fwd_list_base<_Tp, _Alloc> { static_assert(is_same::type, _Tp>::value, "std::forward_list must have a non-const, non-volatile value_type"); static_assert(is_same::value, "std::forward_list must have the same value_type as its allocator"); private: typedef _Fwd_list_base<_Tp, _Alloc> _Base; typedef _Fwd_list_node_base _Node_base; typedef typename _Base::_Node _Node; typedef typename _Base::_Node_alloc_type _Node_alloc_type; typedef typename _Base::_Node_alloc_traits _Node_alloc_traits; typedef allocator_traits<__alloc_rebind<_Alloc, _Tp>> _Alloc_traits; public: typedef _Tp value_type; typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef typename _Base::iterator iterator; typedef typename _Base::const_iterator const_iterator; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef _Alloc allocator_type; forward_list() = default; explicit forward_list(const _Alloc& __al) noexcept : _Base(_Node_alloc_type(__al)) { } forward_list(const forward_list& __list, const _Alloc& __al) : _Base(_Node_alloc_type(__al)) { _M_range_initialize(__list.begin(), __list.end()); } private: forward_list(forward_list&& __list, _Node_alloc_type&& __al, false_type) : _Base(std::move(__list), std::move(__al)) { insert_after(cbefore_begin(), std::__make_move_if_noexcept_iterator(__list.begin()), std::__make_move_if_noexcept_iterator(__list.end())); } forward_list(forward_list&& __list, _Node_alloc_type&& __al, true_type) noexcept : _Base(std::move(__list), _Node_alloc_type(__al), true_type{}) { } public: forward_list(forward_list&& __list, const _Alloc& __al) noexcept(_Node_alloc_traits::_S_always_equal()) : forward_list(std::move(__list), _Node_alloc_type(__al), typename _Node_alloc_traits::is_always_equal{}) { } # 517 "/usr/include/c++/10/bits/forward_list.h" 3 explicit forward_list(size_type __n, const _Alloc& __al = _Alloc()) : _Base(_Node_alloc_type(__al)) { _M_default_initialize(__n); } # 531 "/usr/include/c++/10/bits/forward_list.h" 3 forward_list(size_type __n, const _Tp& __value, const _Alloc& __al = _Alloc()) : _Base(_Node_alloc_type(__al)) { _M_fill_initialize(__n, __value); } # 546 "/usr/include/c++/10/bits/forward_list.h" 3 template> forward_list(_InputIterator __first, _InputIterator __last, const _Alloc& __al = _Alloc()) : _Base(_Node_alloc_type(__al)) { _M_range_initialize(__first, __last); } forward_list(const forward_list& __list) : _Base(_Node_alloc_traits::_S_select_on_copy( __list._M_get_Node_allocator())) { _M_range_initialize(__list.begin(), __list.end()); } # 572 "/usr/include/c++/10/bits/forward_list.h" 3 forward_list(forward_list&&) = default; # 582 "/usr/include/c++/10/bits/forward_list.h" 3 forward_list(std::initializer_list<_Tp> __il, const _Alloc& __al = _Alloc()) : _Base(_Node_alloc_type(__al)) { _M_range_initialize(__il.begin(), __il.end()); } ~forward_list() noexcept { } # 602 "/usr/include/c++/10/bits/forward_list.h" 3 forward_list& operator=(const forward_list& __list); # 617 "/usr/include/c++/10/bits/forward_list.h" 3 forward_list& operator=(forward_list&& __list) noexcept(_Node_alloc_traits::_S_nothrow_move()) { constexpr bool __move_storage = _Node_alloc_traits::_S_propagate_on_move_assign() || _Node_alloc_traits::_S_always_equal(); _M_move_assign(std::move(__list), __bool_constant<__move_storage>()); return *this; } # 636 "/usr/include/c++/10/bits/forward_list.h" 3 forward_list& operator=(std::initializer_list<_Tp> __il) { assign(__il); return *this; } # 655 "/usr/include/c++/10/bits/forward_list.h" 3 template> void assign(_InputIterator __first, _InputIterator __last) { typedef is_assignable<_Tp, decltype(*__first)> __assignable; _M_assign(__first, __last, __assignable()); } # 674 "/usr/include/c++/10/bits/forward_list.h" 3 void assign(size_type __n, const _Tp& __val) { _M_assign_n(__n, __val, is_copy_assignable<_Tp>()); } # 686 "/usr/include/c++/10/bits/forward_list.h" 3 void assign(std::initializer_list<_Tp> __il) { assign(__il.begin(), __il.end()); } allocator_type get_allocator() const noexcept { return allocator_type(this->_M_get_Node_allocator()); } iterator before_begin() noexcept { return iterator(&this->_M_impl._M_head); } const_iterator before_begin() const noexcept { return const_iterator(&this->_M_impl._M_head); } iterator begin() noexcept { return iterator(this->_M_impl._M_head._M_next); } const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_head._M_next); } iterator end() noexcept { return iterator(nullptr); } const_iterator end() const noexcept { return const_iterator(nullptr); } const_iterator cbegin() const noexcept { return const_iterator(this->_M_impl._M_head._M_next); } const_iterator cbefore_begin() const noexcept { return const_iterator(&this->_M_impl._M_head); } const_iterator cend() const noexcept { return const_iterator(nullptr); } [[__nodiscard__]] bool empty() const noexcept { return this->_M_impl._M_head._M_next == nullptr; } size_type max_size() const noexcept { return _Node_alloc_traits::max_size(this->_M_get_Node_allocator()); } reference front() { _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next); return *__front->_M_valptr(); } const_reference front() const { _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next); return *__front->_M_valptr(); } # 828 "/usr/include/c++/10/bits/forward_list.h" 3 template reference emplace_front(_Args&&... __args) { this->_M_insert_after(cbefore_begin(), std::forward<_Args>(__args)...); return front(); } # 853 "/usr/include/c++/10/bits/forward_list.h" 3 void push_front(const _Tp& __val) { this->_M_insert_after(cbefore_begin(), __val); } void push_front(_Tp&& __val) { this->_M_insert_after(cbefore_begin(), std::move(__val)); } # 876 "/usr/include/c++/10/bits/forward_list.h" 3 void pop_front() { this->_M_erase_after(&this->_M_impl._M_head); } # 893 "/usr/include/c++/10/bits/forward_list.h" 3 template iterator emplace_after(const_iterator __pos, _Args&&... __args) { return iterator(this->_M_insert_after(__pos, std::forward<_Args>(__args)...)); } # 911 "/usr/include/c++/10/bits/forward_list.h" 3 iterator insert_after(const_iterator __pos, const _Tp& __val) { return iterator(this->_M_insert_after(__pos, __val)); } iterator insert_after(const_iterator __pos, _Tp&& __val) { return iterator(this->_M_insert_after(__pos, std::move(__val))); } # 937 "/usr/include/c++/10/bits/forward_list.h" 3 iterator insert_after(const_iterator __pos, size_type __n, const _Tp& __val); # 955 "/usr/include/c++/10/bits/forward_list.h" 3 template> iterator insert_after(const_iterator __pos, _InputIterator __first, _InputIterator __last); # 976 "/usr/include/c++/10/bits/forward_list.h" 3 iterator insert_after(const_iterator __pos, std::initializer_list<_Tp> __il) { return insert_after(__pos, __il.begin(), __il.end()); } # 997 "/usr/include/c++/10/bits/forward_list.h" 3 iterator erase_after(const_iterator __pos) { return iterator(this->_M_erase_after(const_cast<_Node_base*> (__pos._M_node))); } # 1020 "/usr/include/c++/10/bits/forward_list.h" 3 iterator erase_after(const_iterator __pos, const_iterator __last) { return iterator(this->_M_erase_after(const_cast<_Node_base*> (__pos._M_node), const_cast<_Node_base*> (__last._M_node))); } # 1039 "/usr/include/c++/10/bits/forward_list.h" 3 void swap(forward_list& __list) noexcept { std::swap(this->_M_impl._M_head._M_next, __list._M_impl._M_head._M_next); _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(), __list._M_get_Node_allocator()); } # 1059 "/usr/include/c++/10/bits/forward_list.h" 3 void resize(size_type __sz); # 1074 "/usr/include/c++/10/bits/forward_list.h" 3 void resize(size_type __sz, const value_type& __val); # 1085 "/usr/include/c++/10/bits/forward_list.h" 3 void clear() noexcept { this->_M_erase_after(&this->_M_impl._M_head, nullptr); } # 1102 "/usr/include/c++/10/bits/forward_list.h" 3 void splice_after(const_iterator __pos, forward_list&& __list) noexcept { if (!__list.empty()) _M_splice_after(__pos, __list.before_begin(), __list.end()); } void splice_after(const_iterator __pos, forward_list& __list) noexcept { splice_after(__pos, std::move(__list)); } # 1123 "/usr/include/c++/10/bits/forward_list.h" 3 void splice_after(const_iterator __pos, forward_list&& __list, const_iterator __i) noexcept; void splice_after(const_iterator __pos, forward_list& __list, const_iterator __i) noexcept { splice_after(__pos, std::move(__list), __i); } # 1146 "/usr/include/c++/10/bits/forward_list.h" 3 void splice_after(const_iterator __pos, forward_list&&, const_iterator __before, const_iterator __last) noexcept { _M_splice_after(__pos, __before, __last); } void splice_after(const_iterator __pos, forward_list&, const_iterator __before, const_iterator __last) noexcept { _M_splice_after(__pos, __before, __last); } private: using __remove_return_type = size_type; public: # 1180 "/usr/include/c++/10/bits/forward_list.h" 3 __attribute__((__abi_tag__("__cxx20"))) __remove_return_type remove(const _Tp& __val); # 1195 "/usr/include/c++/10/bits/forward_list.h" 3 template __remove_return_type remove_if(_Pred __pred); # 1209 "/usr/include/c++/10/bits/forward_list.h" 3 __attribute__((__abi_tag__("__cxx20"))) __remove_return_type unique() { return unique(std::equal_to<_Tp>()); } # 1228 "/usr/include/c++/10/bits/forward_list.h" 3 template __remove_return_type unique(_BinPred __binary_pred); # 1241 "/usr/include/c++/10/bits/forward_list.h" 3 void merge(forward_list&& __list) { merge(std::move(__list), std::less<_Tp>()); } void merge(forward_list& __list) { merge(std::move(__list)); } # 1260 "/usr/include/c++/10/bits/forward_list.h" 3 template void merge(forward_list&& __list, _Comp __comp); template void merge(forward_list& __list, _Comp __comp) { merge(std::move(__list), __comp); } void sort() { sort(std::less<_Tp>()); } template void sort(_Comp __comp); void reverse() noexcept { this->_M_impl._M_head._M_reverse_after(); } private: template void _M_range_initialize(_InputIterator __first, _InputIterator __last); void _M_fill_initialize(size_type __n, const value_type& __value); iterator _M_splice_after(const_iterator __pos, const_iterator __before, const_iterator __last); void _M_default_initialize(size_type __n); void _M_default_insert_after(const_iterator __pos, size_type __n); void _M_move_assign(forward_list&& __list, true_type) noexcept { clear(); this->_M_impl._M_head._M_next = __list._M_impl._M_head._M_next; __list._M_impl._M_head._M_next = nullptr; std::__alloc_on_move(this->_M_get_Node_allocator(), __list._M_get_Node_allocator()); } void _M_move_assign(forward_list&& __list, false_type) { if (__list._M_get_Node_allocator() == this->_M_get_Node_allocator()) _M_move_assign(std::move(__list), true_type()); else this->assign(std::make_move_iterator(__list.begin()), std::make_move_iterator(__list.end())); } template void _M_assign(_InputIterator __first, _InputIterator __last, true_type) { auto __prev = before_begin(); auto __curr = begin(); auto __end = end(); while (__curr != __end && __first != __last) { *__curr = *__first; ++__prev; ++__curr; ++__first; } if (__first != __last) insert_after(__prev, __first, __last); else if (__curr != __end) erase_after(__prev, __end); } template void _M_assign(_InputIterator __first, _InputIterator __last, false_type) { clear(); insert_after(cbefore_begin(), __first, __last); } void _M_assign_n(size_type __n, const _Tp& __val, true_type) { auto __prev = before_begin(); auto __curr = begin(); auto __end = end(); while (__curr != __end && __n > 0) { *__curr = __val; ++__prev; ++__curr; --__n; } if (__n > 0) insert_after(__prev, __n, __val); else if (__curr != __end) erase_after(__prev, __end); } void _M_assign_n(size_type __n, const _Tp& __val, false_type) { clear(); insert_after(cbefore_begin(), __n, __val); } }; template::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>> forward_list(_InputIterator, _InputIterator, _Allocator = _Allocator()) -> forward_list<_ValT, _Allocator>; # 1427 "/usr/include/c++/10/bits/forward_list.h" 3 template bool operator==(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly); # 1444 "/usr/include/c++/10/bits/forward_list.h" 3 template inline __detail::__synth3way_t<_Tp> operator<=>(const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) { return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __detail::__synth3way); } # 1503 "/usr/include/c++/10/bits/forward_list.h" 3 template inline void swap(forward_list<_Tp, _Alloc>& __lx, forward_list<_Tp, _Alloc>& __ly) noexcept(noexcept(__lx.swap(__ly))) { __lx.swap(__ly); } } # 39 "/usr/include/c++/10/forward_list" 2 3 # 1 "/usr/include/c++/10/bits/forward_list.tcc" 1 3 # 33 "/usr/include/c++/10/bits/forward_list.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template _Fwd_list_base<_Tp, _Alloc>:: _Fwd_list_base(_Fwd_list_base&& __lst, _Node_alloc_type&& __a) : _M_impl(std::move(__a)) { if (__lst._M_get_Node_allocator() == _M_get_Node_allocator()) this->_M_impl._M_head = std::move(__lst._M_impl._M_head); } template template _Fwd_list_node_base* _Fwd_list_base<_Tp, _Alloc>:: _M_insert_after(const_iterator __pos, _Args&&... __args) { _Fwd_list_node_base* __to = const_cast<_Fwd_list_node_base*>(__pos._M_node); _Node* __thing = _M_create_node(std::forward<_Args>(__args)...); __thing->_M_next = __to->_M_next; __to->_M_next = __thing; return __to->_M_next; } template _Fwd_list_node_base* _Fwd_list_base<_Tp, _Alloc>:: _M_erase_after(_Fwd_list_node_base* __pos) { _Node* __curr = static_cast<_Node*>(__pos->_M_next); __pos->_M_next = __curr->_M_next; _Node_alloc_traits::destroy(_M_get_Node_allocator(), __curr->_M_valptr()); __curr->~_Node(); _M_put_node(__curr); return __pos->_M_next; } template _Fwd_list_node_base* _Fwd_list_base<_Tp, _Alloc>:: _M_erase_after(_Fwd_list_node_base* __pos, _Fwd_list_node_base* __last) { _Node* __curr = static_cast<_Node*>(__pos->_M_next); while (__curr != __last) { _Node* __temp = __curr; __curr = static_cast<_Node*>(__curr->_M_next); _Node_alloc_traits::destroy(_M_get_Node_allocator(), __temp->_M_valptr()); __temp->~_Node(); _M_put_node(__temp); } __pos->_M_next = __last; return __last; } template template void forward_list<_Tp, _Alloc>:: _M_range_initialize(_InputIterator __first, _InputIterator __last) { _Node_base* __to = &this->_M_impl._M_head; for (; __first != __last; ++__first) { __to->_M_next = this->_M_create_node(*__first); __to = __to->_M_next; } } template void forward_list<_Tp, _Alloc>:: _M_fill_initialize(size_type __n, const value_type& __value) { _Node_base* __to = &this->_M_impl._M_head; for (; __n; --__n) { __to->_M_next = this->_M_create_node(__value); __to = __to->_M_next; } } template void forward_list<_Tp, _Alloc>:: _M_default_initialize(size_type __n) { _Node_base* __to = &this->_M_impl._M_head; for (; __n; --__n) { __to->_M_next = this->_M_create_node(); __to = __to->_M_next; } } template forward_list<_Tp, _Alloc>& forward_list<_Tp, _Alloc>:: operator=(const forward_list& __list) { if (std::__addressof(__list) != this) { if (_Node_alloc_traits::_S_propagate_on_copy_assign()) { auto& __this_alloc = this->_M_get_Node_allocator(); auto& __that_alloc = __list._M_get_Node_allocator(); if (!_Node_alloc_traits::_S_always_equal() && __this_alloc != __that_alloc) { clear(); } std::__alloc_on_copy(__this_alloc, __that_alloc); } assign(__list.cbegin(), __list.cend()); } return *this; } template void forward_list<_Tp, _Alloc>:: _M_default_insert_after(const_iterator __pos, size_type __n) { const_iterator __saved_pos = __pos; try { for (; __n; --__n) __pos = emplace_after(__pos); } catch(...) { erase_after(__saved_pos, ++__pos); throw; } } template void forward_list<_Tp, _Alloc>:: resize(size_type __sz) { iterator __k = before_begin(); size_type __len = 0; while (__k._M_next() != end() && __len < __sz) { ++__k; ++__len; } if (__len == __sz) erase_after(__k, end()); else _M_default_insert_after(__k, __sz - __len); } template void forward_list<_Tp, _Alloc>:: resize(size_type __sz, const value_type& __val) { iterator __k = before_begin(); size_type __len = 0; while (__k._M_next() != end() && __len < __sz) { ++__k; ++__len; } if (__len == __sz) erase_after(__k, end()); else insert_after(__k, __sz - __len, __val); } template typename forward_list<_Tp, _Alloc>::iterator forward_list<_Tp, _Alloc>:: _M_splice_after(const_iterator __pos, const_iterator __before, const_iterator __last) { _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node); _Node_base* __b = const_cast<_Node_base*>(__before._M_node); _Node_base* __end = __b; while (__end && __end->_M_next != __last._M_node) __end = __end->_M_next; if (__b != __end) return iterator(__tmp->_M_transfer_after(__b, __end)); else return iterator(__tmp); } template void forward_list<_Tp, _Alloc>:: splice_after(const_iterator __pos, forward_list&&, const_iterator __i) noexcept { const_iterator __j = __i; ++__j; if (__pos == __i || __pos == __j) return; _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node); __tmp->_M_transfer_after(const_cast<_Node_base*>(__i._M_node), const_cast<_Node_base*>(__j._M_node)); } template typename forward_list<_Tp, _Alloc>::iterator forward_list<_Tp, _Alloc>:: insert_after(const_iterator __pos, size_type __n, const _Tp& __val) { if (__n) { forward_list __tmp(__n, __val, get_allocator()); return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end()); } else return iterator(const_cast<_Node_base*>(__pos._M_node)); } template template typename forward_list<_Tp, _Alloc>::iterator forward_list<_Tp, _Alloc>:: insert_after(const_iterator __pos, _InputIterator __first, _InputIterator __last) { forward_list __tmp(__first, __last, get_allocator()); if (!__tmp.empty()) return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end()); else return iterator(const_cast<_Node_base*>(__pos._M_node)); } template auto forward_list<_Tp, _Alloc>:: remove(const _Tp& __val) -> __remove_return_type { size_type __removed __attribute__((__unused__)) = 0; _Node_base* __curr = &this->_M_impl._M_head; _Node_base* __extra = nullptr; while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next)) { if (*__tmp->_M_valptr() == __val) { if (__tmp->_M_valptr() != std::__addressof(__val)) { this->_M_erase_after(__curr); __removed++; continue; } else __extra = __curr; } __curr = __curr->_M_next; } if (__extra) { this->_M_erase_after(__extra); __removed++; } return __removed; } template template auto forward_list<_Tp, _Alloc>:: remove_if(_Pred __pred) -> __remove_return_type { size_type __removed __attribute__((__unused__)) = 0; _Node_base* __curr = &this->_M_impl._M_head; while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next)) { if (__pred(*__tmp->_M_valptr())) { this->_M_erase_after(__curr); __removed++; } else __curr = __curr->_M_next; } return __removed; } template template auto forward_list<_Tp, _Alloc>:: unique(_BinPred __binary_pred) -> __remove_return_type { iterator __first = begin(); iterator __last = end(); if (__first == __last) return 0; size_type __removed __attribute__((__unused__)) = 0; iterator __next = __first; while (++__next != __last) { if (__binary_pred(*__first, *__next)) { erase_after(__first); __removed++; } else __first = __next; __next = __first; } return __removed; } template template void forward_list<_Tp, _Alloc>:: merge(forward_list&& __list, _Comp __comp) { _Node_base* __node = &this->_M_impl._M_head; while (__node->_M_next && __list._M_impl._M_head._M_next) { if (__comp(*static_cast<_Node*> (__list._M_impl._M_head._M_next)->_M_valptr(), *static_cast<_Node*> (__node->_M_next)->_M_valptr())) __node->_M_transfer_after(&__list._M_impl._M_head, __list._M_impl._M_head._M_next); __node = __node->_M_next; } if (__list._M_impl._M_head._M_next) *__node = std::move(__list._M_impl._M_head); } template bool operator==(const forward_list<_Tp, _Alloc>& __lx, const forward_list<_Tp, _Alloc>& __ly) { auto __ix = __lx.cbegin(); auto __iy = __ly.cbegin(); while (__ix != __lx.cend() && __iy != __ly.cend()) { if (!(*__ix == *__iy)) return false; ++__ix; ++__iy; } if (__ix == __lx.cend() && __iy == __ly.cend()) return true; else return false; } template template void forward_list<_Tp, _Alloc>:: sort(_Comp __comp) { _Node* __list = static_cast<_Node*>(this->_M_impl._M_head._M_next); if (!__list) return; unsigned long __insize = 1; while (1) { _Node* __p = __list; __list = nullptr; _Node* __tail = nullptr; unsigned long __nmerges = 0; while (__p) { ++__nmerges; _Node* __q = __p; unsigned long __psize = 0; for (unsigned long __i = 0; __i < __insize; ++__i) { ++__psize; __q = static_cast<_Node*>(__q->_M_next); if (!__q) break; } unsigned long __qsize = __insize; while (__psize > 0 || (__qsize > 0 && __q)) { _Node* __e; if (__psize == 0) { __e = __q; __q = static_cast<_Node*>(__q->_M_next); --__qsize; } else if (__qsize == 0 || !__q) { __e = __p; __p = static_cast<_Node*>(__p->_M_next); --__psize; } else if (!__comp(*__q->_M_valptr(), *__p->_M_valptr())) { __e = __p; __p = static_cast<_Node*>(__p->_M_next); --__psize; } else { __e = __q; __q = static_cast<_Node*>(__q->_M_next); --__qsize; } if (__tail) __tail->_M_next = __e; else __list = __e; __tail = __e; } __p = __q; } __tail->_M_next = nullptr; if (__nmerges <= 1) { this->_M_impl._M_head._M_next = __list; return; } __insize *= 2; } } } # 41 "/usr/include/c++/10/forward_list" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template using forward_list = std::forward_list<_Tp, polymorphic_allocator<_Tp>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename forward_list<_Tp, _Alloc>::size_type erase_if(forward_list<_Tp, _Alloc>& __cont, _Predicate __pred) { return __cont.remove_if(__pred); } template inline typename forward_list<_Tp, _Alloc>::size_type erase(forward_list<_Tp, _Alloc>& __cont, const _Up& __value) { using __elem_type = typename forward_list<_Tp, _Alloc>::value_type; return std::erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; }); } } # 58 "all-std.cxx" 2 # 1 "/usr/include/c++/10/list" 1 3 # 58 "/usr/include/c++/10/list" 3 # 59 "/usr/include/c++/10/list" 3 # 1 "/usr/include/c++/10/bits/stl_list.h" 1 3 # 67 "/usr/include/c++/10/bits/stl_list.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { struct _List_node_base { _List_node_base* _M_next; _List_node_base* _M_prev; static void swap(_List_node_base& __x, _List_node_base& __y) noexcept; void _M_transfer(_List_node_base* const __first, _List_node_base* const __last) noexcept; void _M_reverse() noexcept; void _M_hook(_List_node_base* const __position) noexcept; void _M_unhook() noexcept; }; struct _List_node_header : public _List_node_base { std::size_t _M_size; _List_node_header() noexcept { _M_init(); } _List_node_header(_List_node_header&& __x) noexcept : _List_node_base{ __x._M_next, __x._M_prev } , _M_size(__x._M_size) { if (__x._M_base()->_M_next == __x._M_base()) this->_M_next = this->_M_prev = this; else { this->_M_next->_M_prev = this->_M_prev->_M_next = this->_M_base(); __x._M_init(); } } void _M_move_nodes(_List_node_header&& __x) { _List_node_base* const __xnode = __x._M_base(); if (__xnode->_M_next == __xnode) _M_init(); else { _List_node_base* const __node = this->_M_base(); __node->_M_next = __xnode->_M_next; __node->_M_prev = __xnode->_M_prev; __node->_M_next->_M_prev = __node->_M_prev->_M_next = __node; _M_size = __x._M_size; __x._M_init(); } } void _M_init() noexcept { this->_M_next = this->_M_prev = this; this->_M_size = 0; } private: _List_node_base* _M_base() { return this; } }; } template struct _List_node : public __detail::_List_node_base { __gnu_cxx::__aligned_membuf<_Tp> _M_storage; _Tp* _M_valptr() { return _M_storage._M_ptr(); } _Tp const* _M_valptr() const { return _M_storage._M_ptr(); } }; template struct _List_iterator { typedef _List_iterator<_Tp> _Self; typedef _List_node<_Tp> _Node; typedef ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; typedef _Tp value_type; typedef _Tp* pointer; typedef _Tp& reference; _List_iterator() noexcept : _M_node() { } explicit _List_iterator(__detail::_List_node_base* __x) noexcept : _M_node(__x) { } _Self _M_const_cast() const noexcept { return *this; } reference operator*() const noexcept { return *static_cast<_Node*>(_M_node)->_M_valptr(); } pointer operator->() const noexcept { return static_cast<_Node*>(_M_node)->_M_valptr(); } _Self& operator++() noexcept { _M_node = _M_node->_M_next; return *this; } _Self operator++(int) noexcept { _Self __tmp = *this; _M_node = _M_node->_M_next; return __tmp; } _Self& operator--() noexcept { _M_node = _M_node->_M_prev; return *this; } _Self operator--(int) noexcept { _Self __tmp = *this; _M_node = _M_node->_M_prev; return __tmp; } friend bool operator==(const _Self& __x, const _Self& __y) noexcept { return __x._M_node == __y._M_node; } # 257 "/usr/include/c++/10/bits/stl_list.h" 3 __detail::_List_node_base* _M_node; }; template struct _List_const_iterator { typedef _List_const_iterator<_Tp> _Self; typedef const _List_node<_Tp> _Node; typedef _List_iterator<_Tp> iterator; typedef ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; typedef _Tp value_type; typedef const _Tp* pointer; typedef const _Tp& reference; _List_const_iterator() noexcept : _M_node() { } explicit _List_const_iterator(const __detail::_List_node_base* __x) noexcept : _M_node(__x) { } _List_const_iterator(const iterator& __x) noexcept : _M_node(__x._M_node) { } iterator _M_const_cast() const noexcept { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); } reference operator*() const noexcept { return *static_cast<_Node*>(_M_node)->_M_valptr(); } pointer operator->() const noexcept { return static_cast<_Node*>(_M_node)->_M_valptr(); } _Self& operator++() noexcept { _M_node = _M_node->_M_next; return *this; } _Self operator++(int) noexcept { _Self __tmp = *this; _M_node = _M_node->_M_next; return __tmp; } _Self& operator--() noexcept { _M_node = _M_node->_M_prev; return *this; } _Self operator--(int) noexcept { _Self __tmp = *this; _M_node = _M_node->_M_prev; return __tmp; } friend bool operator==(const _Self& __x, const _Self& __y) noexcept { return __x._M_node == __y._M_node; } # 343 "/usr/include/c++/10/bits/stl_list.h" 3 const __detail::_List_node_base* _M_node; }; namespace __cxx11 { template class _List_base { protected: typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type; typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tp_alloc_traits; typedef typename _Tp_alloc_traits::template rebind<_List_node<_Tp> >::other _Node_alloc_type; typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits; static size_t _S_distance(const __detail::_List_node_base* __first, const __detail::_List_node_base* __last) { size_t __n = 0; while (__first != __last) { __first = __first->_M_next; ++__n; } return __n; } struct _List_impl : public _Node_alloc_type { __detail::_List_node_header _M_node; _List_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value) : _Node_alloc_type() { } _List_impl(const _Node_alloc_type& __a) noexcept : _Node_alloc_type(__a) { } _List_impl(_List_impl&&) = default; _List_impl(_Node_alloc_type&& __a, _List_impl&& __x) : _Node_alloc_type(std::move(__a)), _M_node(std::move(__x._M_node)) { } _List_impl(_Node_alloc_type&& __a) noexcept : _Node_alloc_type(std::move(__a)) { } }; _List_impl _M_impl; size_t _M_get_size() const { return _M_impl._M_node._M_size; } void _M_set_size(size_t __n) { _M_impl._M_node._M_size = __n; } void _M_inc_size(size_t __n) { _M_impl._M_node._M_size += __n; } void _M_dec_size(size_t __n) { _M_impl._M_node._M_size -= __n; } size_t _M_distance(const __detail::_List_node_base* __first, const __detail::_List_node_base* __last) const { return _S_distance(__first, __last); } size_t _M_node_count() const { return _M_get_size(); } # 440 "/usr/include/c++/10/bits/stl_list.h" 3 typename _Node_alloc_traits::pointer _M_get_node() { return _Node_alloc_traits::allocate(_M_impl, 1); } void _M_put_node(typename _Node_alloc_traits::pointer __p) noexcept { _Node_alloc_traits::deallocate(_M_impl, __p, 1); } public: typedef _Alloc allocator_type; _Node_alloc_type& _M_get_Node_allocator() noexcept { return _M_impl; } const _Node_alloc_type& _M_get_Node_allocator() const noexcept { return _M_impl; } _List_base() = default; _List_base(const _Node_alloc_type& __a) noexcept : _M_impl(__a) { } _List_base(_List_base&&) = default; _List_base(_List_base&& __x, _Node_alloc_type&& __a) : _M_impl(std::move(__a)) { if (__x._M_get_Node_allocator() == _M_get_Node_allocator()) _M_move_nodes(std::move(__x)); } _List_base(_Node_alloc_type&& __a, _List_base&& __x) : _M_impl(std::move(__a), std::move(__x._M_impl)) { } _List_base(_Node_alloc_type&& __a) : _M_impl(std::move(__a)) { } void _M_move_nodes(_List_base&& __x) { _M_impl._M_node._M_move_nodes(std::move(__x._M_impl._M_node)); } ~_List_base() noexcept { _M_clear(); } void _M_clear() noexcept; void _M_init() noexcept { this->_M_impl._M_node._M_init(); } }; # 555 "/usr/include/c++/10/bits/stl_list.h" 3 template > class list : protected _List_base<_Tp, _Alloc> { # 568 "/usr/include/c++/10/bits/stl_list.h" 3 static_assert(is_same::type, _Tp>::value, "std::list must have a non-const, non-volatile value_type"); static_assert(is_same::value, "std::list must have the same value_type as its allocator"); typedef _List_base<_Tp, _Alloc> _Base; typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; typedef typename _Base::_Tp_alloc_traits _Tp_alloc_traits; typedef typename _Base::_Node_alloc_type _Node_alloc_type; typedef typename _Base::_Node_alloc_traits _Node_alloc_traits; public: typedef _Tp value_type; typedef typename _Tp_alloc_traits::pointer pointer; typedef typename _Tp_alloc_traits::const_pointer const_pointer; typedef typename _Tp_alloc_traits::reference reference; typedef typename _Tp_alloc_traits::const_reference const_reference; typedef _List_iterator<_Tp> iterator; typedef _List_const_iterator<_Tp> const_iterator; typedef std::reverse_iterator const_reverse_iterator; typedef std::reverse_iterator reverse_iterator; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Alloc allocator_type; protected: typedef _List_node<_Tp> _Node; using _Base::_M_impl; using _Base::_M_put_node; using _Base::_M_get_node; using _Base::_M_get_Node_allocator; # 630 "/usr/include/c++/10/bits/stl_list.h" 3 template _Node* _M_create_node(_Args&&... __args) { auto __p = this->_M_get_node(); auto& __alloc = _M_get_Node_allocator(); __allocated_ptr<_Node_alloc_type> __guard{__alloc, __p}; _Node_alloc_traits::construct(__alloc, __p->_M_valptr(), std::forward<_Args>(__args)...); __guard = nullptr; return __p; } static size_t _S_distance(const_iterator __first, const_iterator __last) { return std::distance(__first, __last); } size_t _M_node_count() const { return this->_M_get_size(); } # 665 "/usr/include/c++/10/bits/stl_list.h" 3 public: list() = default; # 682 "/usr/include/c++/10/bits/stl_list.h" 3 explicit list(const allocator_type& __a) noexcept : _Base(_Node_alloc_type(__a)) { } # 695 "/usr/include/c++/10/bits/stl_list.h" 3 explicit list(size_type __n, const allocator_type& __a = allocator_type()) : _Base(_Node_alloc_type(__a)) { _M_default_initialize(__n); } # 708 "/usr/include/c++/10/bits/stl_list.h" 3 list(size_type __n, const value_type& __value, const allocator_type& __a = allocator_type()) : _Base(_Node_alloc_type(__a)) { _M_fill_initialize(__n, __value); } # 735 "/usr/include/c++/10/bits/stl_list.h" 3 list(const list& __x) : _Base(_Node_alloc_traits:: _S_select_on_copy(__x._M_get_Node_allocator())) { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } # 748 "/usr/include/c++/10/bits/stl_list.h" 3 list(list&&) = default; # 758 "/usr/include/c++/10/bits/stl_list.h" 3 list(initializer_list __l, const allocator_type& __a = allocator_type()) : _Base(_Node_alloc_type(__a)) { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); } list(const list& __x, const allocator_type& __a) : _Base(_Node_alloc_type(__a)) { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } private: list(list&& __x, const allocator_type& __a, true_type) noexcept : _Base(_Node_alloc_type(__a), std::move(__x)) { } list(list&& __x, const allocator_type& __a, false_type) : _Base(_Node_alloc_type(__a)) { if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator()) this->_M_move_nodes(std::move(__x)); else insert(begin(), std::__make_move_if_noexcept_iterator(__x.begin()), std::__make_move_if_noexcept_iterator(__x.end())); } public: list(list&& __x, const allocator_type& __a) noexcept(_Node_alloc_traits::_S_always_equal()) : list(std::move(__x), __a, typename _Node_alloc_traits::is_always_equal{}) { } # 801 "/usr/include/c++/10/bits/stl_list.h" 3 template> list(_InputIterator __first, _InputIterator __last, const allocator_type& __a = allocator_type()) : _Base(_Node_alloc_type(__a)) { _M_initialize_dispatch(__first, __last, __false_type()); } # 827 "/usr/include/c++/10/bits/stl_list.h" 3 ~list() = default; # 838 "/usr/include/c++/10/bits/stl_list.h" 3 list& operator=(const list& __x); # 852 "/usr/include/c++/10/bits/stl_list.h" 3 list& operator=(list&& __x) noexcept(_Node_alloc_traits::_S_nothrow_move()) { constexpr bool __move_storage = _Node_alloc_traits::_S_propagate_on_move_assign() || _Node_alloc_traits::_S_always_equal(); _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); return *this; } # 870 "/usr/include/c++/10/bits/stl_list.h" 3 list& operator=(initializer_list __l) { this->assign(__l.begin(), __l.end()); return *this; } # 888 "/usr/include/c++/10/bits/stl_list.h" 3 void assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); } # 905 "/usr/include/c++/10/bits/stl_list.h" 3 template> void assign(_InputIterator __first, _InputIterator __last) { _M_assign_dispatch(__first, __last, __false_type()); } # 929 "/usr/include/c++/10/bits/stl_list.h" 3 void assign(initializer_list __l) { this->_M_assign_dispatch(__l.begin(), __l.end(), __false_type()); } allocator_type get_allocator() const noexcept { return allocator_type(_Base::_M_get_Node_allocator()); } iterator begin() noexcept { return iterator(this->_M_impl._M_node._M_next); } const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_node._M_next); } iterator end() noexcept { return iterator(&this->_M_impl._M_node); } const_iterator end() const noexcept { return const_iterator(&this->_M_impl._M_node); } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } const_iterator cbegin() const noexcept { return const_iterator(this->_M_impl._M_node._M_next); } const_iterator cend() const noexcept { return const_iterator(&this->_M_impl._M_node); } const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } [[__nodiscard__]] bool empty() const noexcept { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; } size_type size() const noexcept { return _M_node_count(); } size_type max_size() const noexcept { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); } # 1078 "/usr/include/c++/10/bits/stl_list.h" 3 void resize(size_type __new_size); # 1091 "/usr/include/c++/10/bits/stl_list.h" 3 void resize(size_type __new_size, const value_type& __x); # 1113 "/usr/include/c++/10/bits/stl_list.h" 3 reference front() noexcept { return *begin(); } const_reference front() const noexcept { return *begin(); } reference back() noexcept { iterator __tmp = end(); --__tmp; return *__tmp; } const_reference back() const noexcept { const_iterator __tmp = end(); --__tmp; return *__tmp; } # 1160 "/usr/include/c++/10/bits/stl_list.h" 3 void push_front(const value_type& __x) { this->_M_insert(begin(), __x); } void push_front(value_type&& __x) { this->_M_insert(begin(), std::move(__x)); } template reference emplace_front(_Args&&... __args) { this->_M_insert(begin(), std::forward<_Args>(__args)...); return front(); } # 1196 "/usr/include/c++/10/bits/stl_list.h" 3 void pop_front() noexcept { this->_M_erase(begin()); } # 1210 "/usr/include/c++/10/bits/stl_list.h" 3 void push_back(const value_type& __x) { this->_M_insert(end(), __x); } void push_back(value_type&& __x) { this->_M_insert(end(), std::move(__x)); } template reference emplace_back(_Args&&... __args) { this->_M_insert(end(), std::forward<_Args>(__args)...); return back(); } # 1245 "/usr/include/c++/10/bits/stl_list.h" 3 void pop_back() noexcept { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); } # 1262 "/usr/include/c++/10/bits/stl_list.h" 3 template iterator emplace(const_iterator __position, _Args&&... __args); # 1277 "/usr/include/c++/10/bits/stl_list.h" 3 iterator insert(const_iterator __position, const value_type& __x); # 1307 "/usr/include/c++/10/bits/stl_list.h" 3 iterator insert(const_iterator __position, value_type&& __x) { return emplace(__position, std::move(__x)); } # 1326 "/usr/include/c++/10/bits/stl_list.h" 3 iterator insert(const_iterator __p, initializer_list __l) { return this->insert(__p, __l.begin(), __l.end()); } # 1346 "/usr/include/c++/10/bits/stl_list.h" 3 iterator insert(const_iterator __position, size_type __n, const value_type& __x); # 1385 "/usr/include/c++/10/bits/stl_list.h" 3 template> iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last); # 1429 "/usr/include/c++/10/bits/stl_list.h" 3 iterator erase(const_iterator __position) noexcept; # 1454 "/usr/include/c++/10/bits/stl_list.h" 3 iterator erase(const_iterator __first, const_iterator __last) noexcept { while (__first != __last) __first = erase(__first); return __last._M_const_cast(); } # 1477 "/usr/include/c++/10/bits/stl_list.h" 3 void swap(list& __x) noexcept { __detail::_List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node); size_t __xsize = __x._M_get_size(); __x._M_set_size(this->_M_get_size()); this->_M_set_size(__xsize); _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(), __x._M_get_Node_allocator()); } void clear() noexcept { _Base::_M_clear(); _Base::_M_init(); } # 1516 "/usr/include/c++/10/bits/stl_list.h" 3 void splice(const_iterator __position, list&& __x) noexcept { if (!__x.empty()) { _M_check_equal_allocators(__x); this->_M_transfer(__position._M_const_cast(), __x.begin(), __x.end()); this->_M_inc_size(__x._M_get_size()); __x._M_set_size(0); } } void splice(const_iterator __position, list& __x) noexcept { splice(__position, std::move(__x)); } # 1552 "/usr/include/c++/10/bits/stl_list.h" 3 void splice(const_iterator __position, list&& __x, const_iterator __i) noexcept # 1567 "/usr/include/c++/10/bits/stl_list.h" 3 { iterator __j = __i._M_const_cast(); ++__j; if (__position == __i || __position == __j) return; if (this != std::__addressof(__x)) _M_check_equal_allocators(__x); this->_M_transfer(__position._M_const_cast(), __i._M_const_cast(), __j); this->_M_inc_size(1); __x._M_dec_size(1); } # 1594 "/usr/include/c++/10/bits/stl_list.h" 3 void splice(const_iterator __position, list& __x, const_iterator __i) noexcept { splice(__position, std::move(__x), __i); } # 1613 "/usr/include/c++/10/bits/stl_list.h" 3 void splice(const_iterator __position, list&& __x, const_iterator __first, const_iterator __last) noexcept # 1633 "/usr/include/c++/10/bits/stl_list.h" 3 { if (__first != __last) { if (this != std::__addressof(__x)) _M_check_equal_allocators(__x); size_t __n = _S_distance(__first, __last); this->_M_inc_size(__n); __x._M_dec_size(__n); this->_M_transfer(__position._M_const_cast(), __first._M_const_cast(), __last._M_const_cast()); } } # 1663 "/usr/include/c++/10/bits/stl_list.h" 3 void splice(const_iterator __position, list& __x, const_iterator __first, const_iterator __last) noexcept { splice(__position, std::move(__x), __first, __last); } private: typedef size_type __remove_return_type; public: # 1692 "/usr/include/c++/10/bits/stl_list.h" 3 __attribute__((__abi_tag__("__cxx20"))) __remove_return_type remove(const _Tp& __value); # 1707 "/usr/include/c++/10/bits/stl_list.h" 3 template __remove_return_type remove_if(_Predicate); # 1721 "/usr/include/c++/10/bits/stl_list.h" 3 __attribute__((__abi_tag__("__cxx20"))) __remove_return_type unique(); # 1737 "/usr/include/c++/10/bits/stl_list.h" 3 template __remove_return_type unique(_BinaryPredicate); # 1753 "/usr/include/c++/10/bits/stl_list.h" 3 void merge(list&& __x); void merge(list& __x) { merge(std::move(__x)); } # 1778 "/usr/include/c++/10/bits/stl_list.h" 3 template void merge(list&& __x, _StrictWeakOrdering __comp); template void merge(list& __x, _StrictWeakOrdering __comp) { merge(std::move(__x), __comp); } # 1797 "/usr/include/c++/10/bits/stl_list.h" 3 void reverse() noexcept { this->_M_impl._M_node._M_reverse(); } void sort(); template void sort(_StrictWeakOrdering); protected: template void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) { _M_fill_initialize(static_cast(__n), __x); } template void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { for (; __first != __last; ++__first) emplace_back(*__first); } void _M_fill_initialize(size_type __n, const value_type& __x) { for (; __n; --__n) push_back(__x); } void _M_default_initialize(size_type __n) { for (; __n; --__n) emplace_back(); } void _M_default_append(size_type __n); # 1875 "/usr/include/c++/10/bits/stl_list.h" 3 template void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) { _M_fill_assign(__n, __val); } template void _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type); void _M_fill_assign(size_type __n, const value_type& __val); void _M_transfer(iterator __position, iterator __first, iterator __last) { __position._M_node->_M_transfer(__first._M_node, __last._M_node); } # 1907 "/usr/include/c++/10/bits/stl_list.h" 3 template void _M_insert(iterator __position, _Args&&... __args) { _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); __tmp->_M_hook(__position._M_node); this->_M_inc_size(1); } void _M_erase(iterator __position) noexcept { this->_M_dec_size(1); __position._M_node->_M_unhook(); _Node* __n = static_cast<_Node*>(__position._M_node); _Node_alloc_traits::destroy(_M_get_Node_allocator(), __n->_M_valptr()); _M_put_node(__n); } void _M_check_equal_allocators(list& __x) noexcept { if (std::__alloc_neq:: _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator())) __builtin_abort(); } const_iterator _M_resize_pos(size_type& __new_size) const; void _M_move_assign(list&& __x, true_type) noexcept { this->_M_clear(); this->_M_move_nodes(std::move(__x)); std::__alloc_on_move(this->_M_get_Node_allocator(), __x._M_get_Node_allocator()); } void _M_move_assign(list&& __x, false_type) { if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator()) _M_move_assign(std::move(__x), true_type{}); else _M_assign_dispatch(std::make_move_iterator(__x.begin()), std::make_move_iterator(__x.end()), __false_type{}); } }; template::value_type, typename _Allocator = allocator<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireAllocator<_Allocator>> list(_InputIterator, _InputIterator, _Allocator = _Allocator()) -> list<_ValT, _Allocator>; } # 1993 "/usr/include/c++/10/bits/stl_list.h" 3 template inline bool operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) { if (__x.size() != __y.size()) return false; typedef typename list<_Tp, _Alloc>::const_iterator const_iterator; const_iterator __end1 = __x.end(); const_iterator __end2 = __y.end(); const_iterator __i1 = __x.begin(); const_iterator __i2 = __y.begin(); while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) { ++__i1; ++__i2; } return __i1 == __end1 && __i2 == __end2; } # 2028 "/usr/include/c++/10/bits/stl_list.h" 3 template inline __detail::__synth3way_t<_Tp> operator<=>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) { return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __detail::__synth3way); } # 2080 "/usr/include/c++/10/bits/stl_list.h" 3 template inline void swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline ptrdiff_t __distance(std::_List_iterator<_Tp> __first, std::_List_iterator<_Tp> __last, input_iterator_tag __tag) { typedef std::_List_const_iterator<_Tp> _CIter; return std::__distance(_CIter(__first), _CIter(__last), __tag); } template inline ptrdiff_t __distance(std::_List_const_iterator<_Tp> __first, std::_List_const_iterator<_Tp> __last, input_iterator_tag) { typedef __detail::_List_node_header _Sentinel; std::_List_const_iterator<_Tp> __beyond = __last; ++__beyond; const bool __whole = __first == __beyond; if (__builtin_constant_p (__whole) && __whole) return static_cast(__last._M_node)->_M_size; ptrdiff_t __n = 0; while (__first != __last) { ++__first; ++__n; } return __n; } } # 64 "/usr/include/c++/10/list" 2 3 # 1 "/usr/include/c++/10/bits/list.tcc" 1 3 # 59 "/usr/include/c++/10/bits/list.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template void _List_base<_Tp, _Alloc>:: _M_clear() noexcept { typedef _List_node<_Tp> _Node; __detail::_List_node_base* __cur = _M_impl._M_node._M_next; while (__cur != &_M_impl._M_node) { _Node* __tmp = static_cast<_Node*>(__cur); __cur = __tmp->_M_next; _Tp* __val = __tmp->_M_valptr(); _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val); _M_put_node(__tmp); } } template template typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>:: emplace(const_iterator __position, _Args&&... __args) { _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); __tmp->_M_hook(__position._M_const_cast()._M_node); this->_M_inc_size(1); return iterator(__tmp); } template typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>:: insert(const_iterator __position, const value_type& __x) { _Node* __tmp = _M_create_node(__x); __tmp->_M_hook(__position._M_const_cast()._M_node); this->_M_inc_size(1); return iterator(__tmp); } template typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>:: insert(const_iterator __position, size_type __n, const value_type& __x) { if (__n) { list __tmp(__n, __x, get_allocator()); iterator __it = __tmp.begin(); splice(__position, __tmp); return __it; } return __position._M_const_cast(); } template template typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>:: insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { list __tmp(__first, __last, get_allocator()); if (!__tmp.empty()) { iterator __it = __tmp.begin(); splice(__position, __tmp); return __it; } return __position._M_const_cast(); } template typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>:: erase(const_iterator __position) noexcept { iterator __ret = iterator(__position._M_node->_M_next); _M_erase(__position._M_const_cast()); return __ret; } # 173 "/usr/include/c++/10/bits/list.tcc" 3 template typename list<_Tp, _Alloc>::const_iterator list<_Tp, _Alloc>:: _M_resize_pos(size_type& __new_size) const { const_iterator __i; const size_type __len = size(); if (__new_size < __len) { if (__new_size <= __len / 2) { __i = begin(); std::advance(__i, __new_size); } else { __i = end(); ptrdiff_t __num_erase = __len - __new_size; std::advance(__i, -__num_erase); } __new_size = 0; return __i; } else __i = end(); __new_size -= __len; return __i; } template void list<_Tp, _Alloc>:: _M_default_append(size_type __n) { size_type __i = 0; try { for (; __i < __n; ++__i) emplace_back(); } catch(...) { for (; __i; --__i) pop_back(); throw; } } template void list<_Tp, _Alloc>:: resize(size_type __new_size) { const_iterator __i = _M_resize_pos(__new_size); if (__new_size) _M_default_append(__new_size); else erase(__i, end()); } template void list<_Tp, _Alloc>:: resize(size_type __new_size, const value_type& __x) { const_iterator __i = _M_resize_pos(__new_size); if (__new_size) insert(end(), __new_size, __x); else erase(__i, end()); } # 265 "/usr/include/c++/10/bits/list.tcc" 3 template list<_Tp, _Alloc>& list<_Tp, _Alloc>:: operator=(const list& __x) { if (this != std::__addressof(__x)) { if (_Node_alloc_traits::_S_propagate_on_copy_assign()) { auto& __this_alloc = this->_M_get_Node_allocator(); auto& __that_alloc = __x._M_get_Node_allocator(); if (!_Node_alloc_traits::_S_always_equal() && __this_alloc != __that_alloc) { clear(); } std::__alloc_on_copy(__this_alloc, __that_alloc); } _M_assign_dispatch(__x.begin(), __x.end(), __false_type()); } return *this; } template void list<_Tp, _Alloc>:: _M_fill_assign(size_type __n, const value_type& __val) { iterator __i = begin(); for (; __i != end() && __n > 0; ++__i, --__n) *__i = __val; if (__n > 0) insert(end(), __n, __val); else erase(__i, end()); } template template void list<_Tp, _Alloc>:: _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, __false_type) { iterator __first1 = begin(); iterator __last1 = end(); for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) *__first1 = *__first2; if (__first2 == __last2) erase(__first1, __last1); else insert(__last1, __first2, __last2); } template typename list<_Tp, _Alloc>::__remove_return_type list<_Tp, _Alloc>:: remove(const value_type& __value) { size_type __removed __attribute__((__unused__)) = 0; iterator __first = begin(); iterator __last = end(); iterator __extra = __last; while (__first != __last) { iterator __next = __first; ++__next; if (*__first == __value) { if (std::__addressof(*__first) != std::__addressof(__value)) { _M_erase(__first); __removed++; } else __extra = __first; } __first = __next; } if (__extra != __last) { _M_erase(__extra); __removed++; } return __removed; } template typename list<_Tp, _Alloc>::__remove_return_type list<_Tp, _Alloc>:: unique() { iterator __first = begin(); iterator __last = end(); if (__first == __last) return 0; size_type __removed __attribute__((__unused__)) = 0; iterator __next = __first; while (++__next != __last) { if (*__first == *__next) { _M_erase(__next); __removed++; } else __first = __next; __next = __first; } return __removed; } template void list<_Tp, _Alloc>:: merge(list&& __x) { if (this != std::__addressof(__x)) { _M_check_equal_allocators(__x); iterator __first1 = begin(); iterator __last1 = end(); iterator __first2 = __x.begin(); iterator __last2 = __x.end(); const size_t __orig_size = __x.size(); try { while (__first1 != __last1 && __first2 != __last2) if (*__first2 < *__first1) { iterator __next = __first2; _M_transfer(__first1, __first2, ++__next); __first2 = __next; } else ++__first1; if (__first2 != __last2) _M_transfer(__last1, __first2, __last2); this->_M_inc_size(__x._M_get_size()); __x._M_set_size(0); } catch(...) { const size_t __dist = std::distance(__first2, __last2); this->_M_inc_size(__orig_size - __dist); __x._M_set_size(__dist); throw; } } } template template void list<_Tp, _Alloc>:: merge(list&& __x, _StrictWeakOrdering __comp) { if (this != std::__addressof(__x)) { _M_check_equal_allocators(__x); iterator __first1 = begin(); iterator __last1 = end(); iterator __first2 = __x.begin(); iterator __last2 = __x.end(); const size_t __orig_size = __x.size(); try { while (__first1 != __last1 && __first2 != __last2) if (__comp(*__first2, *__first1)) { iterator __next = __first2; _M_transfer(__first1, __first2, ++__next); __first2 = __next; } else ++__first1; if (__first2 != __last2) _M_transfer(__last1, __first2, __last2); this->_M_inc_size(__x._M_get_size()); __x._M_set_size(0); } catch(...) { const size_t __dist = std::distance(__first2, __last2); this->_M_inc_size(__orig_size - __dist); __x._M_set_size(__dist); throw; } } } template void list<_Tp, _Alloc>:: sort() { if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) { list __carry; list __tmp[64]; list * __fill = __tmp; list * __counter; try { do { __carry.splice(__carry.begin(), *this, begin()); for(__counter = __tmp; __counter != __fill && !__counter->empty(); ++__counter) { __counter->merge(__carry); __carry.swap(*__counter); } __carry.swap(*__counter); if (__counter == __fill) ++__fill; } while ( !empty() ); for (__counter = __tmp + 1; __counter != __fill; ++__counter) __counter->merge(*(__counter - 1)); swap( *(__fill - 1) ); } catch(...) { this->splice(this->end(), __carry); for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i) this->splice(this->end(), __tmp[__i]); throw; } } } template template typename list<_Tp, _Alloc>::__remove_return_type list<_Tp, _Alloc>:: remove_if(_Predicate __pred) { size_type __removed __attribute__((__unused__)) = 0; iterator __first = begin(); iterator __last = end(); while (__first != __last) { iterator __next = __first; ++__next; if (__pred(*__first)) { _M_erase(__first); __removed++; } __first = __next; } return __removed; } template template typename list<_Tp, _Alloc>::__remove_return_type list<_Tp, _Alloc>:: unique(_BinaryPredicate __binary_pred) { iterator __first = begin(); iterator __last = end(); if (__first == __last) return 0; size_type __removed __attribute__((__unused__)) = 0; iterator __next = __first; while (++__next != __last) { if (__binary_pred(*__first, *__next)) { _M_erase(__next); __removed++; } else __first = __next; __next = __first; } return __removed; } template template void list<_Tp, _Alloc>:: sort(_StrictWeakOrdering __comp) { if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) { list __carry; list __tmp[64]; list * __fill = __tmp; list * __counter; try { do { __carry.splice(__carry.begin(), *this, begin()); for(__counter = __tmp; __counter != __fill && !__counter->empty(); ++__counter) { __counter->merge(__carry, __comp); __carry.swap(*__counter); } __carry.swap(*__counter); if (__counter == __fill) ++__fill; } while ( !empty() ); for (__counter = __tmp + 1; __counter != __fill; ++__counter) __counter->merge(*(__counter - 1), __comp); swap(*(__fill - 1)); } catch(...) { this->splice(this->end(), __carry); for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i) this->splice(this->end(), __tmp[__i]); throw; } } } } # 65 "/usr/include/c++/10/list" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template using list = std::list<_Tp, polymorphic_allocator<_Tp>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename list<_Tp, _Alloc>::size_type erase_if(list<_Tp, _Alloc>& __cont, _Predicate __pred) { return __cont.remove_if(__pred); } template inline typename list<_Tp, _Alloc>::size_type erase(list<_Tp, _Alloc>& __cont, const _Up& __value) { using __elem_type = typename list<_Tp, _Alloc>::value_type; return std::erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; }); } } # 59 "all-std.cxx" 2 # 1 "/usr/include/c++/10/map" 1 3 # 58 "/usr/include/c++/10/map" 3 # 59 "/usr/include/c++/10/map" 3 # 1 "/usr/include/c++/10/bits/stl_tree.h" 1 3 # 61 "/usr/include/c++/10/bits/stl_tree.h" 3 # 62 "/usr/include/c++/10/bits/stl_tree.h" 3 # 75 "/usr/include/c++/10/bits/stl_tree.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 99 "/usr/include/c++/10/bits/stl_tree.h" 3 enum _Rb_tree_color { _S_red = false, _S_black = true }; struct _Rb_tree_node_base { typedef _Rb_tree_node_base* _Base_ptr; typedef const _Rb_tree_node_base* _Const_Base_ptr; _Rb_tree_color _M_color; _Base_ptr _M_parent; _Base_ptr _M_left; _Base_ptr _M_right; static _Base_ptr _S_minimum(_Base_ptr __x) noexcept { while (__x->_M_left != 0) __x = __x->_M_left; return __x; } static _Const_Base_ptr _S_minimum(_Const_Base_ptr __x) noexcept { while (__x->_M_left != 0) __x = __x->_M_left; return __x; } static _Base_ptr _S_maximum(_Base_ptr __x) noexcept { while (__x->_M_right != 0) __x = __x->_M_right; return __x; } static _Const_Base_ptr _S_maximum(_Const_Base_ptr __x) noexcept { while (__x->_M_right != 0) __x = __x->_M_right; return __x; } }; template struct _Rb_tree_key_compare { _Key_compare _M_key_compare; _Rb_tree_key_compare() noexcept(is_nothrow_default_constructible<_Key_compare>::value) : _M_key_compare() { } _Rb_tree_key_compare(const _Key_compare& __comp) : _M_key_compare(__comp) { } _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default; _Rb_tree_key_compare(_Rb_tree_key_compare&& __x) noexcept(is_nothrow_copy_constructible<_Key_compare>::value) : _M_key_compare(__x._M_key_compare) { } }; struct _Rb_tree_header { _Rb_tree_node_base _M_header; size_t _M_node_count; _Rb_tree_header() noexcept { _M_header._M_color = _S_red; _M_reset(); } _Rb_tree_header(_Rb_tree_header&& __x) noexcept { if (__x._M_header._M_parent != nullptr) _M_move_data(__x); else { _M_header._M_color = _S_red; _M_reset(); } } void _M_move_data(_Rb_tree_header& __from) { _M_header._M_color = __from._M_header._M_color; _M_header._M_parent = __from._M_header._M_parent; _M_header._M_left = __from._M_header._M_left; _M_header._M_right = __from._M_header._M_right; _M_header._M_parent->_M_parent = &_M_header; _M_node_count = __from._M_node_count; __from._M_reset(); } void _M_reset() { _M_header._M_parent = 0; _M_header._M_left = &_M_header; _M_header._M_right = &_M_header; _M_node_count = 0; } }; template struct _Rb_tree_node : public _Rb_tree_node_base { typedef _Rb_tree_node<_Val>* _Link_type; # 231 "/usr/include/c++/10/bits/stl_tree.h" 3 __gnu_cxx::__aligned_membuf<_Val> _M_storage; _Val* _M_valptr() { return _M_storage._M_ptr(); } const _Val* _M_valptr() const { return _M_storage._M_ptr(); } }; __attribute__ ((__pure__)) _Rb_tree_node_base* _Rb_tree_increment(_Rb_tree_node_base* __x) throw (); __attribute__ ((__pure__)) const _Rb_tree_node_base* _Rb_tree_increment(const _Rb_tree_node_base* __x) throw (); __attribute__ ((__pure__)) _Rb_tree_node_base* _Rb_tree_decrement(_Rb_tree_node_base* __x) throw (); __attribute__ ((__pure__)) const _Rb_tree_node_base* _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw (); template struct _Rb_tree_iterator { typedef _Tp value_type; typedef _Tp& reference; typedef _Tp* pointer; typedef bidirectional_iterator_tag iterator_category; typedef ptrdiff_t difference_type; typedef _Rb_tree_iterator<_Tp> _Self; typedef _Rb_tree_node_base::_Base_ptr _Base_ptr; typedef _Rb_tree_node<_Tp>* _Link_type; _Rb_tree_iterator() noexcept : _M_node() { } explicit _Rb_tree_iterator(_Base_ptr __x) noexcept : _M_node(__x) { } reference operator*() const noexcept { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } pointer operator->() const noexcept { return static_cast<_Link_type> (_M_node)->_M_valptr(); } _Self& operator++() noexcept { _M_node = _Rb_tree_increment(_M_node); return *this; } _Self operator++(int) noexcept { _Self __tmp = *this; _M_node = _Rb_tree_increment(_M_node); return __tmp; } _Self& operator--() noexcept { _M_node = _Rb_tree_decrement(_M_node); return *this; } _Self operator--(int) noexcept { _Self __tmp = *this; _M_node = _Rb_tree_decrement(_M_node); return __tmp; } friend bool operator==(const _Self& __x, const _Self& __y) noexcept { return __x._M_node == __y._M_node; } _Base_ptr _M_node; }; template struct _Rb_tree_const_iterator { typedef _Tp value_type; typedef const _Tp& reference; typedef const _Tp* pointer; typedef _Rb_tree_iterator<_Tp> iterator; typedef bidirectional_iterator_tag iterator_category; typedef ptrdiff_t difference_type; typedef _Rb_tree_const_iterator<_Tp> _Self; typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr; typedef const _Rb_tree_node<_Tp>* _Link_type; _Rb_tree_const_iterator() noexcept : _M_node() { } explicit _Rb_tree_const_iterator(_Base_ptr __x) noexcept : _M_node(__x) { } _Rb_tree_const_iterator(const iterator& __it) noexcept : _M_node(__it._M_node) { } iterator _M_const_cast() const noexcept { return iterator(const_cast(_M_node)); } reference operator*() const noexcept { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } pointer operator->() const noexcept { return static_cast<_Link_type>(_M_node)->_M_valptr(); } _Self& operator++() noexcept { _M_node = _Rb_tree_increment(_M_node); return *this; } _Self operator++(int) noexcept { _Self __tmp = *this; _M_node = _Rb_tree_increment(_M_node); return __tmp; } _Self& operator--() noexcept { _M_node = _Rb_tree_decrement(_M_node); return *this; } _Self operator--(int) noexcept { _Self __tmp = *this; _M_node = _Rb_tree_decrement(_M_node); return __tmp; } friend bool operator==(const _Self& __x, const _Self& __y) noexcept { return __x._M_node == __y._M_node; } _Base_ptr _M_node; }; void _Rb_tree_insert_and_rebalance(const bool __insert_left, _Rb_tree_node_base* __x, _Rb_tree_node_base* __p, _Rb_tree_node_base& __header) throw (); _Rb_tree_node_base* _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z, _Rb_tree_node_base& __header) throw (); template> struct __has_is_transparent { }; template struct __has_is_transparent<_Cmp, _SfinaeType, __void_t> { typedef void type; }; template using __has_is_transparent_t = typename __has_is_transparent<_Cmp, _SfinaeType>::type; template struct _Rb_tree_merge_helper { }; template > class _Rb_tree { typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Rb_tree_node<_Val> >::other _Node_allocator; typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits; protected: typedef _Rb_tree_node_base* _Base_ptr; typedef const _Rb_tree_node_base* _Const_Base_ptr; typedef _Rb_tree_node<_Val>* _Link_type; typedef const _Rb_tree_node<_Val>* _Const_Link_type; private: struct _Reuse_or_alloc_node { _Reuse_or_alloc_node(_Rb_tree& __t) : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t) { if (_M_root) { _M_root->_M_parent = 0; if (_M_nodes->_M_left) _M_nodes = _M_nodes->_M_left; } else _M_nodes = 0; } _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete; ~_Reuse_or_alloc_node() { _M_t._M_erase(static_cast<_Link_type>(_M_root)); } template _Link_type operator()(_Arg&& __arg) { _Link_type __node = static_cast<_Link_type>(_M_extract()); if (__node) { _M_t._M_destroy_node(__node); _M_t._M_construct_node(__node, std::forward<_Arg>(__arg)); return __node; } return _M_t._M_create_node(std::forward<_Arg>(__arg)); } private: _Base_ptr _M_extract() { if (!_M_nodes) return _M_nodes; _Base_ptr __node = _M_nodes; _M_nodes = _M_nodes->_M_parent; if (_M_nodes) { if (_M_nodes->_M_right == __node) { _M_nodes->_M_right = 0; if (_M_nodes->_M_left) { _M_nodes = _M_nodes->_M_left; while (_M_nodes->_M_right) _M_nodes = _M_nodes->_M_right; if (_M_nodes->_M_left) _M_nodes = _M_nodes->_M_left; } } else _M_nodes->_M_left = 0; } else _M_root = 0; return __node; } _Base_ptr _M_root; _Base_ptr _M_nodes; _Rb_tree& _M_t; }; struct _Alloc_node { _Alloc_node(_Rb_tree& __t) : _M_t(__t) { } template _Link_type operator()(_Arg&& __arg) const { return _M_t._M_create_node(std::forward<_Arg>(__arg)); } private: _Rb_tree& _M_t; }; public: typedef _Key key_type; typedef _Val value_type; typedef value_type* pointer; typedef const value_type* const_pointer; typedef value_type& reference; typedef const value_type& const_reference; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Alloc allocator_type; _Node_allocator& _M_get_Node_allocator() noexcept { return this->_M_impl; } const _Node_allocator& _M_get_Node_allocator() const noexcept { return this->_M_impl; } allocator_type get_allocator() const noexcept { return allocator_type(_M_get_Node_allocator()); } protected: _Link_type _M_get_node() { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); } void _M_put_node(_Link_type __p) noexcept { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); } # 611 "/usr/include/c++/10/bits/stl_tree.h" 3 template void _M_construct_node(_Link_type __node, _Args&&... __args) { try { ::new(__node) _Rb_tree_node<_Val>; _Alloc_traits::construct(_M_get_Node_allocator(), __node->_M_valptr(), std::forward<_Args>(__args)...); } catch(...) { __node->~_Rb_tree_node<_Val>(); _M_put_node(__node); throw; } } template _Link_type _M_create_node(_Args&&... __args) { _Link_type __tmp = _M_get_node(); _M_construct_node(__tmp, std::forward<_Args>(__args)...); return __tmp; } void _M_destroy_node(_Link_type __p) noexcept { _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr()); __p->~_Rb_tree_node<_Val>(); } void _M_drop_node(_Link_type __p) noexcept { _M_destroy_node(__p); _M_put_node(__p); } template _Link_type _M_clone_node(_Const_Link_type __x, _NodeGen& __node_gen) { _Link_type __tmp = __node_gen(*__x->_M_valptr()); __tmp->_M_color = __x->_M_color; __tmp->_M_left = 0; __tmp->_M_right = 0; return __tmp; } protected: template struct _Rb_tree_impl : public _Node_allocator , public _Rb_tree_key_compare<_Key_compare> , public _Rb_tree_header { typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare; _Rb_tree_impl() noexcept(is_nothrow_default_constructible<_Node_allocator>::value && is_nothrow_default_constructible<_Base_key_compare>::value) : _Node_allocator() { } _Rb_tree_impl(const _Rb_tree_impl& __x) : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x)) , _Base_key_compare(__x._M_key_compare) { } _Rb_tree_impl(_Rb_tree_impl&&) = default; explicit _Rb_tree_impl(_Node_allocator&& __a) : _Node_allocator(std::move(__a)) { } _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a) : _Node_allocator(std::move(__a)), _Base_key_compare(std::move(__x)), _Rb_tree_header(std::move(__x)) { } _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a) : _Node_allocator(std::move(__a)), _Base_key_compare(__comp) { } }; _Rb_tree_impl<_Compare> _M_impl; protected: _Base_ptr& _M_root() noexcept { return this->_M_impl._M_header._M_parent; } _Const_Base_ptr _M_root() const noexcept { return this->_M_impl._M_header._M_parent; } _Base_ptr& _M_leftmost() noexcept { return this->_M_impl._M_header._M_left; } _Const_Base_ptr _M_leftmost() const noexcept { return this->_M_impl._M_header._M_left; } _Base_ptr& _M_rightmost() noexcept { return this->_M_impl._M_header._M_right; } _Const_Base_ptr _M_rightmost() const noexcept { return this->_M_impl._M_header._M_right; } _Link_type _M_begin() noexcept { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); } _Const_Link_type _M_begin() const noexcept { return static_cast<_Const_Link_type> (this->_M_impl._M_header._M_parent); } _Base_ptr _M_end() noexcept { return &this->_M_impl._M_header; } _Const_Base_ptr _M_end() const noexcept { return &this->_M_impl._M_header; } static const _Key& _S_key(_Const_Link_type __x) { static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{}, "comparison object must be invocable " "with two arguments of key type"); if constexpr (__is_invocable<_Compare&, const _Key&, const _Key&>{}) static_assert( is_invocable_v, "comparison object must be invocable as const"); return _KeyOfValue()(*__x->_M_valptr()); } static _Link_type _S_left(_Base_ptr __x) noexcept { return static_cast<_Link_type>(__x->_M_left); } static _Const_Link_type _S_left(_Const_Base_ptr __x) noexcept { return static_cast<_Const_Link_type>(__x->_M_left); } static _Link_type _S_right(_Base_ptr __x) noexcept { return static_cast<_Link_type>(__x->_M_right); } static _Const_Link_type _S_right(_Const_Base_ptr __x) noexcept { return static_cast<_Const_Link_type>(__x->_M_right); } static const _Key& _S_key(_Const_Base_ptr __x) { return _S_key(static_cast<_Const_Link_type>(__x)); } static _Base_ptr _S_minimum(_Base_ptr __x) noexcept { return _Rb_tree_node_base::_S_minimum(__x); } static _Const_Base_ptr _S_minimum(_Const_Base_ptr __x) noexcept { return _Rb_tree_node_base::_S_minimum(__x); } static _Base_ptr _S_maximum(_Base_ptr __x) noexcept { return _Rb_tree_node_base::_S_maximum(__x); } static _Const_Base_ptr _S_maximum(_Const_Base_ptr __x) noexcept { return _Rb_tree_node_base::_S_maximum(__x); } public: typedef _Rb_tree_iterator iterator; typedef _Rb_tree_const_iterator const_iterator; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; using node_type = _Node_handle<_Key, _Val, _Node_allocator>; using insert_return_type = _Node_insert_return< conditional_t, const_iterator, iterator>, node_type>; pair<_Base_ptr, _Base_ptr> _M_get_insert_unique_pos(const key_type& __k); pair<_Base_ptr, _Base_ptr> _M_get_insert_equal_pos(const key_type& __k); pair<_Base_ptr, _Base_ptr> _M_get_insert_hint_unique_pos(const_iterator __pos, const key_type& __k); pair<_Base_ptr, _Base_ptr> _M_get_insert_hint_equal_pos(const_iterator __pos, const key_type& __k); private: template iterator _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&); iterator _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z); template iterator _M_insert_lower(_Base_ptr __y, _Arg&& __v); template iterator _M_insert_equal_lower(_Arg&& __x); iterator _M_insert_lower_node(_Base_ptr __p, _Link_type __z); iterator _M_insert_equal_lower_node(_Link_type __z); # 889 "/usr/include/c++/10/bits/stl_tree.h" 3 template _Link_type _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen&); template _Link_type _M_copy(const _Rb_tree& __x, _NodeGen& __gen) { _Link_type __root = _M_copy(__x._M_begin(), _M_end(), __gen); _M_leftmost() = _S_minimum(__root); _M_rightmost() = _S_maximum(__root); _M_impl._M_node_count = __x._M_impl._M_node_count; return __root; } _Link_type _M_copy(const _Rb_tree& __x) { _Alloc_node __an(*this); return _M_copy(__x, __an); } void _M_erase(_Link_type __x); iterator _M_lower_bound(_Link_type __x, _Base_ptr __y, const _Key& __k); const_iterator _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y, const _Key& __k) const; iterator _M_upper_bound(_Link_type __x, _Base_ptr __y, const _Key& __k); const_iterator _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y, const _Key& __k) const; public: _Rb_tree() = default; _Rb_tree(const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_impl(__comp, _Node_allocator(__a)) { } _Rb_tree(const _Rb_tree& __x) : _M_impl(__x._M_impl) { if (__x._M_root() != 0) _M_root() = _M_copy(__x); } _Rb_tree(const allocator_type& __a) : _M_impl(_Node_allocator(__a)) { } _Rb_tree(const _Rb_tree& __x, const allocator_type& __a) : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a)) { if (__x._M_root() != nullptr) _M_root() = _M_copy(__x); } _Rb_tree(_Rb_tree&&) = default; _Rb_tree(_Rb_tree&& __x, const allocator_type& __a) : _Rb_tree(std::move(__x), _Node_allocator(__a)) { } private: _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type) noexcept(is_nothrow_default_constructible<_Compare>::value) : _M_impl(std::move(__x._M_impl), std::move(__a)) { } _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type) : _M_impl(__x._M_impl._M_key_compare, std::move(__a)) { if (__x._M_root() != nullptr) _M_move_data(__x, false_type{}); } public: _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a) noexcept( noexcept( _Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(), std::declval())) ) : _Rb_tree(std::move(__x), std::move(__a), typename _Alloc_traits::is_always_equal{}) { } ~_Rb_tree() noexcept { _M_erase(_M_begin()); } _Rb_tree& operator=(const _Rb_tree& __x); _Compare key_comp() const { return _M_impl._M_key_compare; } iterator begin() noexcept { return iterator(this->_M_impl._M_header._M_left); } const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_header._M_left); } iterator end() noexcept { return iterator(&this->_M_impl._M_header); } const_iterator end() const noexcept { return const_iterator(&this->_M_impl._M_header); } reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } reverse_iterator rend() noexcept { return reverse_iterator(begin()); } const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } [[__nodiscard__]] bool empty() const noexcept { return _M_impl._M_node_count == 0; } size_type size() const noexcept { return _M_impl._M_node_count; } size_type max_size() const noexcept { return _Alloc_traits::max_size(_M_get_Node_allocator()); } void swap(_Rb_tree& __t) noexcept(__is_nothrow_swappable<_Compare>::value); template pair _M_insert_unique(_Arg&& __x); template iterator _M_insert_equal(_Arg&& __x); template iterator _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&); template iterator _M_insert_unique_(const_iterator __pos, _Arg&& __x) { _Alloc_node __an(*this); return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an); } template iterator _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&); template iterator _M_insert_equal_(const_iterator __pos, _Arg&& __x) { _Alloc_node __an(*this); return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an); } template pair _M_emplace_unique(_Args&&... __args); template iterator _M_emplace_equal(_Args&&... __args); template iterator _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args); template iterator _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args); template using __same_value_type = is_same::value_type>; template __enable_if_t<__same_value_type<_InputIterator>::value> _M_insert_range_unique(_InputIterator __first, _InputIterator __last) { _Alloc_node __an(*this); for (; __first != __last; ++__first) _M_insert_unique_(end(), *__first, __an); } template __enable_if_t::value> _M_insert_range_unique(_InputIterator __first, _InputIterator __last) { for (; __first != __last; ++__first) _M_emplace_unique(*__first); } template __enable_if_t<__same_value_type<_InputIterator>::value> _M_insert_range_equal(_InputIterator __first, _InputIterator __last) { _Alloc_node __an(*this); for (; __first != __last; ++__first) _M_insert_equal_(end(), *__first, __an); } template __enable_if_t::value> _M_insert_range_equal(_InputIterator __first, _InputIterator __last) { _Alloc_node __an(*this); for (; __first != __last; ++__first) _M_emplace_equal(*__first); } # 1186 "/usr/include/c++/10/bits/stl_tree.h" 3 private: void _M_erase_aux(const_iterator __position); void _M_erase_aux(const_iterator __first, const_iterator __last); public: __attribute ((__abi_tag__ ("cxx11"))) iterator erase(const_iterator __position) { ; const_iterator __result = __position; ++__result; _M_erase_aux(__position); return __result._M_const_cast(); } __attribute ((__abi_tag__ ("cxx11"))) iterator erase(iterator __position) { ; iterator __result = __position; ++__result; _M_erase_aux(__position); return __result; } # 1235 "/usr/include/c++/10/bits/stl_tree.h" 3 size_type erase(const key_type& __x); __attribute ((__abi_tag__ ("cxx11"))) iterator erase(const_iterator __first, const_iterator __last) { _M_erase_aux(__first, __last); return __last._M_const_cast(); } # 1258 "/usr/include/c++/10/bits/stl_tree.h" 3 void clear() noexcept { _M_erase(_M_begin()); _M_impl._M_reset(); } iterator find(const key_type& __k); const_iterator find(const key_type& __k) const; size_type count(const key_type& __k) const; iterator lower_bound(const key_type& __k) { return _M_lower_bound(_M_begin(), _M_end(), __k); } const_iterator lower_bound(const key_type& __k) const { return _M_lower_bound(_M_begin(), _M_end(), __k); } iterator upper_bound(const key_type& __k) { return _M_upper_bound(_M_begin(), _M_end(), __k); } const_iterator upper_bound(const key_type& __k) const { return _M_upper_bound(_M_begin(), _M_end(), __k); } pair equal_range(const key_type& __k); pair equal_range(const key_type& __k) const; template> iterator _M_find_tr(const _Kt& __k) { const _Rb_tree* __const_this = this; return __const_this->_M_find_tr(__k)._M_const_cast(); } template> const_iterator _M_find_tr(const _Kt& __k) const { auto __j = _M_lower_bound_tr(__k); if (__j != end() && _M_impl._M_key_compare(__k, _S_key(__j._M_node))) __j = end(); return __j; } template> size_type _M_count_tr(const _Kt& __k) const { auto __p = _M_equal_range_tr(__k); return std::distance(__p.first, __p.second); } template> iterator _M_lower_bound_tr(const _Kt& __k) { const _Rb_tree* __const_this = this; return __const_this->_M_lower_bound_tr(__k)._M_const_cast(); } template> const_iterator _M_lower_bound_tr(const _Kt& __k) const { auto __x = _M_begin(); auto __y = _M_end(); while (__x != 0) if (!_M_impl._M_key_compare(_S_key(__x), __k)) { __y = __x; __x = _S_left(__x); } else __x = _S_right(__x); return const_iterator(__y); } template> iterator _M_upper_bound_tr(const _Kt& __k) { const _Rb_tree* __const_this = this; return __const_this->_M_upper_bound_tr(__k)._M_const_cast(); } template> const_iterator _M_upper_bound_tr(const _Kt& __k) const { auto __x = _M_begin(); auto __y = _M_end(); while (__x != 0) if (_M_impl._M_key_compare(__k, _S_key(__x))) { __y = __x; __x = _S_left(__x); } else __x = _S_right(__x); return const_iterator(__y); } template> pair _M_equal_range_tr(const _Kt& __k) { const _Rb_tree* __const_this = this; auto __ret = __const_this->_M_equal_range_tr(__k); return { __ret.first._M_const_cast(), __ret.second._M_const_cast() }; } template> pair _M_equal_range_tr(const _Kt& __k) const { auto __low = _M_lower_bound_tr(__k); auto __high = __low; auto& __cmp = _M_impl._M_key_compare; while (__high != end() && !__cmp(__k, _S_key(__high._M_node))) ++__high; return { __low, __high }; } bool __rb_verify() const; _Rb_tree& operator=(_Rb_tree&&) noexcept(_Alloc_traits::_S_nothrow_move() && is_nothrow_move_assignable<_Compare>::value); template void _M_assign_unique(_Iterator, _Iterator); template void _M_assign_equal(_Iterator, _Iterator); private: void _M_move_data(_Rb_tree& __x, true_type) { _M_impl._M_move_data(__x._M_impl); } void _M_move_data(_Rb_tree&, false_type); void _M_move_assign(_Rb_tree&, true_type); void _M_move_assign(_Rb_tree&, false_type); public: insert_return_type _M_reinsert_node_unique(node_type&& __nh) { insert_return_type __ret; if (__nh.empty()) __ret.position = end(); else { ; auto __res = _M_get_insert_unique_pos(__nh._M_key()); if (__res.second) { __ret.position = _M_insert_node(__res.first, __res.second, __nh._M_ptr); __nh._M_ptr = nullptr; __ret.inserted = true; } else { __ret.node = std::move(__nh); __ret.position = iterator(__res.first); __ret.inserted = false; } } return __ret; } iterator _M_reinsert_node_equal(node_type&& __nh) { iterator __ret; if (__nh.empty()) __ret = end(); else { ; auto __res = _M_get_insert_equal_pos(__nh._M_key()); if (__res.second) __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr); else __ret = _M_insert_equal_lower_node(__nh._M_ptr); __nh._M_ptr = nullptr; } return __ret; } iterator _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh) { iterator __ret; if (__nh.empty()) __ret = end(); else { ; auto __res = _M_get_insert_hint_unique_pos(__hint, __nh._M_key()); if (__res.second) { __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr); __nh._M_ptr = nullptr; } else __ret = iterator(__res.first); } return __ret; } iterator _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh) { iterator __ret; if (__nh.empty()) __ret = end(); else { ; auto __res = _M_get_insert_hint_equal_pos(__hint, __nh._M_key()); if (__res.second) __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr); else __ret = _M_insert_equal_lower_node(__nh._M_ptr); __nh._M_ptr = nullptr; } return __ret; } node_type extract(const_iterator __pos) { auto __ptr = _Rb_tree_rebalance_for_erase( __pos._M_const_cast()._M_node, _M_impl._M_header); --_M_impl._M_node_count; return { static_cast<_Link_type>(__ptr), _M_get_Node_allocator() }; } node_type extract(const key_type& __k) { node_type __nh; auto __pos = find(__k); if (__pos != end()) __nh = extract(const_iterator(__pos)); return __nh; } template using _Compatible_tree = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>; template friend class _Rb_tree_merge_helper; template void _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept { using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>; for (auto __i = __src.begin(), __end = __src.end(); __i != __end;) { auto __pos = __i++; auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos)); if (__res.second) { auto& __src_impl = _Merge_helper::_S_get_impl(__src); auto __ptr = _Rb_tree_rebalance_for_erase( __pos._M_node, __src_impl._M_header); --__src_impl._M_node_count; _M_insert_node(__res.first, __res.second, static_cast<_Link_type>(__ptr)); } } } template void _M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept { using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>; for (auto __i = __src.begin(), __end = __src.end(); __i != __end;) { auto __pos = __i++; auto __res = _M_get_insert_equal_pos(_KeyOfValue()(*__pos)); if (__res.second) { auto& __src_impl = _Merge_helper::_S_get_impl(__src); auto __ptr = _Rb_tree_rebalance_for_erase( __pos._M_node, __src_impl._M_header); --__src_impl._M_node_count; _M_insert_node(__res.first, __res.second, static_cast<_Link_type>(__ptr)); } } } friend bool operator==(const _Rb_tree& __x, const _Rb_tree& __y) { return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin()); } friend auto operator<=>(const _Rb_tree& __x, const _Rb_tree& __y) { if constexpr (requires { typename __detail::__synth3way_t<_Val>; }) return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __detail::__synth3way); } # 1650 "/usr/include/c++/10/bits/stl_tree.h" 3 }; template inline void swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) { __x.swap(__y); } template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_move_data(_Rb_tree& __x, false_type) { if (_M_get_Node_allocator() == __x._M_get_Node_allocator()) _M_move_data(__x, true_type()); else { _Alloc_node __an(*this); auto __lbd = [&__an](const value_type& __cval) { auto& __val = const_cast(__cval); return __an(std::move_if_noexcept(__val)); }; _M_root() = _M_copy(__x, __lbd); } } template inline void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_move_assign(_Rb_tree& __x, true_type) { clear(); if (__x._M_root() != nullptr) _M_move_data(__x, true_type()); std::__alloc_on_move(_M_get_Node_allocator(), __x._M_get_Node_allocator()); } template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_move_assign(_Rb_tree& __x, false_type) { if (_M_get_Node_allocator() == __x._M_get_Node_allocator()) return _M_move_assign(__x, true_type{}); _Reuse_or_alloc_node __roan(*this); _M_impl._M_reset(); if (__x._M_root() != nullptr) { auto __lbd = [&__roan](const value_type& __cval) { auto& __val = const_cast(__cval); return __roan(std::move(__val)); }; _M_root() = _M_copy(__x, __lbd); __x.clear(); } } template inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: operator=(_Rb_tree&& __x) noexcept(_Alloc_traits::_S_nothrow_move() && is_nothrow_move_assignable<_Compare>::value) { _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare); _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()>()); return *this; } template template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_assign_unique(_Iterator __first, _Iterator __last) { _Reuse_or_alloc_node __roan(*this); _M_impl._M_reset(); for (; __first != __last; ++__first) _M_insert_unique_(end(), *__first, __roan); } template template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_assign_equal(_Iterator __first, _Iterator __last) { _Reuse_or_alloc_node __roan(*this); _M_impl._M_reset(); for (; __first != __last; ++__first) _M_insert_equal_(end(), *__first, __roan); } template _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: operator=(const _Rb_tree& __x) { if (this != &__x) { if (_Alloc_traits::_S_propagate_on_copy_assign()) { auto& __this_alloc = this->_M_get_Node_allocator(); auto& __that_alloc = __x._M_get_Node_allocator(); if (!_Alloc_traits::_S_always_equal() && __this_alloc != __that_alloc) { clear(); std::__alloc_on_copy(__this_alloc, __that_alloc); } } _Reuse_or_alloc_node __roan(*this); _M_impl._M_reset(); _M_impl._M_key_compare = __x._M_impl._M_key_compare; if (__x._M_root() != 0) _M_root() = _M_copy(__x, __roan); } return *this; } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_(_Base_ptr __x, _Base_ptr __p, _Arg&& __v, _NodeGen& __node_gen) { bool __insert_left = (__x != 0 || __p == _M_end() || _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__p))); _Link_type __z = __node_gen(std::forward<_Arg>(__v)); _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, this->_M_impl._M_header); ++_M_impl._M_node_count; return iterator(__z); } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_lower(_Base_ptr __p, _Arg&& __v) { bool __insert_left = (__p == _M_end() || !_M_impl._M_key_compare(_S_key(__p), _KeyOfValue()(__v))); _Link_type __z = _M_create_node(std::forward<_Arg>(__v)); _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, this->_M_impl._M_header); ++_M_impl._M_node_count; return iterator(__z); } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_equal_lower(_Arg&& __v) { _Link_type __x = _M_begin(); _Base_ptr __y = _M_end(); while (__x != 0) { __y = __x; __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ? _S_left(__x) : _S_right(__x); } return _M_insert_lower(__y, std::forward<_Arg>(__v)); } template template typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>:: _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen& __node_gen) { _Link_type __top = _M_clone_node(__x, __node_gen); __top->_M_parent = __p; try { if (__x->_M_right) __top->_M_right = _M_copy(_S_right(__x), __top, __node_gen); __p = __top; __x = _S_left(__x); while (__x != 0) { _Link_type __y = _M_clone_node(__x, __node_gen); __p->_M_left = __y; __y->_M_parent = __p; if (__x->_M_right) __y->_M_right = _M_copy(_S_right(__x), __y, __node_gen); __p = __y; __x = _S_left(__x); } } catch(...) { _M_erase(__top); throw; } return __top; } template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_erase(_Link_type __x) { while (__x != 0) { _M_erase(_S_right(__x)); _Link_type __y = _S_left(__x); _M_drop_node(__x); __x = __y; } } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_lower_bound(_Link_type __x, _Base_ptr __y, const _Key& __k) { while (__x != 0) if (!_M_impl._M_key_compare(_S_key(__x), __k)) __y = __x, __x = _S_left(__x); else __x = _S_right(__x); return iterator(__y); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y, const _Key& __k) const { while (__x != 0) if (!_M_impl._M_key_compare(_S_key(__x), __k)) __y = __x, __x = _S_left(__x); else __x = _S_right(__x); return const_iterator(__y); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_upper_bound(_Link_type __x, _Base_ptr __y, const _Key& __k) { while (__x != 0) if (_M_impl._M_key_compare(__k, _S_key(__x))) __y = __x, __x = _S_left(__x); else __x = _S_right(__x); return iterator(__y); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y, const _Key& __k) const { while (__x != 0) if (_M_impl._M_key_compare(__k, _S_key(__x))) __y = __x, __x = _S_left(__x); else __x = _S_right(__x); return const_iterator(__y); } template pair::iterator, typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: equal_range(const _Key& __k) { _Link_type __x = _M_begin(); _Base_ptr __y = _M_end(); while (__x != 0) { if (_M_impl._M_key_compare(_S_key(__x), __k)) __x = _S_right(__x); else if (_M_impl._M_key_compare(__k, _S_key(__x))) __y = __x, __x = _S_left(__x); else { _Link_type __xu(__x); _Base_ptr __yu(__y); __y = __x, __x = _S_left(__x); __xu = _S_right(__xu); return pair(_M_lower_bound(__x, __y, __k), _M_upper_bound(__xu, __yu, __k)); } } return pair(iterator(__y), iterator(__y)); } template pair::const_iterator, typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: equal_range(const _Key& __k) const { _Const_Link_type __x = _M_begin(); _Const_Base_ptr __y = _M_end(); while (__x != 0) { if (_M_impl._M_key_compare(_S_key(__x), __k)) __x = _S_right(__x); else if (_M_impl._M_key_compare(__k, _S_key(__x))) __y = __x, __x = _S_left(__x); else { _Const_Link_type __xu(__x); _Const_Base_ptr __yu(__y); __y = __x, __x = _S_left(__x); __xu = _S_right(__xu); return pair(_M_lower_bound(__x, __y, __k), _M_upper_bound(__xu, __yu, __k)); } } return pair(const_iterator(__y), const_iterator(__y)); } template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: swap(_Rb_tree& __t) noexcept(__is_nothrow_swappable<_Compare>::value) { if (_M_root() == 0) { if (__t._M_root() != 0) _M_impl._M_move_data(__t._M_impl); } else if (__t._M_root() == 0) __t._M_impl._M_move_data(_M_impl); else { std::swap(_M_root(),__t._M_root()); std::swap(_M_leftmost(),__t._M_leftmost()); std::swap(_M_rightmost(),__t._M_rightmost()); _M_root()->_M_parent = _M_end(); __t._M_root()->_M_parent = __t._M_end(); std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count); } std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare); _Alloc_traits::_S_on_swap(_M_get_Node_allocator(), __t._M_get_Node_allocator()); } template pair::_Base_ptr, typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_get_insert_unique_pos(const key_type& __k) { typedef pair<_Base_ptr, _Base_ptr> _Res; _Link_type __x = _M_begin(); _Base_ptr __y = _M_end(); bool __comp = true; while (__x != 0) { __y = __x; __comp = _M_impl._M_key_compare(__k, _S_key(__x)); __x = __comp ? _S_left(__x) : _S_right(__x); } iterator __j = iterator(__y); if (__comp) { if (__j == begin()) return _Res(__x, __y); else --__j; } if (_M_impl._M_key_compare(_S_key(__j._M_node), __k)) return _Res(__x, __y); return _Res(__j._M_node, 0); } template pair::_Base_ptr, typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_get_insert_equal_pos(const key_type& __k) { typedef pair<_Base_ptr, _Base_ptr> _Res; _Link_type __x = _M_begin(); _Base_ptr __y = _M_end(); while (__x != 0) { __y = __x; __x = _M_impl._M_key_compare(__k, _S_key(__x)) ? _S_left(__x) : _S_right(__x); } return _Res(__x, __y); } template template pair::iterator, bool> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_unique(_Arg&& __v) { typedef pair _Res; pair<_Base_ptr, _Base_ptr> __res = _M_get_insert_unique_pos(_KeyOfValue()(__v)); if (__res.second) { _Alloc_node __an(*this); return _Res(_M_insert_(__res.first, __res.second, std::forward<_Arg>(__v), __an), true); } return _Res(iterator(__res.first), false); } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_equal(_Arg&& __v) { pair<_Base_ptr, _Base_ptr> __res = _M_get_insert_equal_pos(_KeyOfValue()(__v)); _Alloc_node __an(*this); return _M_insert_(__res.first, __res.second, std::forward<_Arg>(__v), __an); } template pair::_Base_ptr, typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_get_insert_hint_unique_pos(const_iterator __position, const key_type& __k) { iterator __pos = __position._M_const_cast(); typedef pair<_Base_ptr, _Base_ptr> _Res; if (__pos._M_node == _M_end()) { if (size() > 0 && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k)) return _Res(0, _M_rightmost()); else return _M_get_insert_unique_pos(__k); } else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node))) { iterator __before = __pos; if (__pos._M_node == _M_leftmost()) return _Res(_M_leftmost(), _M_leftmost()); else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k)) { if (_S_right(__before._M_node) == 0) return _Res(0, __before._M_node); else return _Res(__pos._M_node, __pos._M_node); } else return _M_get_insert_unique_pos(__k); } else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) { iterator __after = __pos; if (__pos._M_node == _M_rightmost()) return _Res(0, _M_rightmost()); else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node))) { if (_S_right(__pos._M_node) == 0) return _Res(0, __pos._M_node); else return _Res(__after._M_node, __after._M_node); } else return _M_get_insert_unique_pos(__k); } else return _Res(__pos._M_node, 0); } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_unique_(const_iterator __position, _Arg&& __v, _NodeGen& __node_gen) { pair<_Base_ptr, _Base_ptr> __res = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v)); if (__res.second) return _M_insert_(__res.first, __res.second, std::forward<_Arg>(__v), __node_gen); return iterator(__res.first); } template pair::_Base_ptr, typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_Base_ptr> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k) { iterator __pos = __position._M_const_cast(); typedef pair<_Base_ptr, _Base_ptr> _Res; if (__pos._M_node == _M_end()) { if (size() > 0 && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost()))) return _Res(0, _M_rightmost()); else return _M_get_insert_equal_pos(__k); } else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) { iterator __before = __pos; if (__pos._M_node == _M_leftmost()) return _Res(_M_leftmost(), _M_leftmost()); else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node))) { if (_S_right(__before._M_node) == 0) return _Res(0, __before._M_node); else return _Res(__pos._M_node, __pos._M_node); } else return _M_get_insert_equal_pos(__k); } else { iterator __after = __pos; if (__pos._M_node == _M_rightmost()) return _Res(0, _M_rightmost()); else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k)) { if (_S_right(__pos._M_node) == 0) return _Res(0, __pos._M_node); else return _Res(__after._M_node, __after._M_node); } else return _Res(0, 0); } } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_equal_(const_iterator __position, _Arg&& __v, _NodeGen& __node_gen) { pair<_Base_ptr, _Base_ptr> __res = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v)); if (__res.second) return _M_insert_(__res.first, __res.second, std::forward<_Arg>(__v), __node_gen); return _M_insert_equal_lower(std::forward<_Arg>(__v)); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z) { bool __insert_left = (__x != 0 || __p == _M_end() || _M_impl._M_key_compare(_S_key(__z), _S_key(__p))); _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, this->_M_impl._M_header); ++_M_impl._M_node_count; return iterator(__z); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_lower_node(_Base_ptr __p, _Link_type __z) { bool __insert_left = (__p == _M_end() || !_M_impl._M_key_compare(_S_key(__p), _S_key(__z))); _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, this->_M_impl._M_header); ++_M_impl._M_node_count; return iterator(__z); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert_equal_lower_node(_Link_type __z) { _Link_type __x = _M_begin(); _Base_ptr __y = _M_end(); while (__x != 0) { __y = __x; __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ? _S_left(__x) : _S_right(__x); } return _M_insert_lower_node(__y, __z); } template template pair::iterator, bool> _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_emplace_unique(_Args&&... __args) { _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); try { typedef pair _Res; auto __res = _M_get_insert_unique_pos(_S_key(__z)); if (__res.second) return _Res(_M_insert_node(__res.first, __res.second, __z), true); _M_drop_node(__z); return _Res(iterator(__res.first), false); } catch(...) { _M_drop_node(__z); throw; } } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_emplace_equal(_Args&&... __args) { _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); try { auto __res = _M_get_insert_equal_pos(_S_key(__z)); return _M_insert_node(__res.first, __res.second, __z); } catch(...) { _M_drop_node(__z); throw; } } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args) { _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); try { auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z)); if (__res.second) return _M_insert_node(__res.first, __res.second, __z); _M_drop_node(__z); return iterator(__res.first); } catch(...) { _M_drop_node(__z); throw; } } template template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args) { _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); try { auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z)); if (__res.second) return _M_insert_node(__res.first, __res.second, __z); return _M_insert_equal_lower_node(__z); } catch(...) { _M_drop_node(__z); throw; } } template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_erase_aux(const_iterator __position) { _Link_type __y = static_cast<_Link_type>(_Rb_tree_rebalance_for_erase (const_cast<_Base_ptr>(__position._M_node), this->_M_impl._M_header)); _M_drop_node(__y); --_M_impl._M_node_count; } template void _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_erase_aux(const_iterator __first, const_iterator __last) { if (__first == begin() && __last == end()) clear(); else while (__first != __last) _M_erase_aux(__first++); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: erase(const _Key& __x) { pair __p = equal_range(__x); const size_type __old_size = size(); _M_erase_aux(__p.first, __p.second); return __old_size - size(); } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: find(const _Key& __k) { iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); return (__j == end() || _M_impl._M_key_compare(__k, _S_key(__j._M_node))) ? end() : __j; } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: find(const _Key& __k) const { const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); return (__j == end() || _M_impl._M_key_compare(__k, _S_key(__j._M_node))) ? end() : __j; } template typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: count(const _Key& __k) const { pair __p = equal_range(__k); const size_type __n = std::distance(__p.first, __p.second); return __n; } __attribute__ ((__pure__)) unsigned int _Rb_tree_black_count(const _Rb_tree_node_base* __node, const _Rb_tree_node_base* __root) throw (); template bool _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const { if (_M_impl._M_node_count == 0 || begin() == end()) return _M_impl._M_node_count == 0 && begin() == end() && this->_M_impl._M_header._M_left == _M_end() && this->_M_impl._M_header._M_right == _M_end(); unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root()); for (const_iterator __it = begin(); __it != end(); ++__it) { _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node); _Const_Link_type __L = _S_left(__x); _Const_Link_type __R = _S_right(__x); if (__x->_M_color == _S_red) if ((__L && __L->_M_color == _S_red) || (__R && __R->_M_color == _S_red)) return false; if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L))) return false; if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x))) return false; if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len) return false; } if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root())) return false; if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root())) return false; return true; } template struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>, _Cmp2> { private: friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>; static auto& _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree) { return __tree._M_impl; } }; } # 61 "/usr/include/c++/10/map" 2 3 # 1 "/usr/include/c++/10/bits/stl_map.h" 1 3 # 66 "/usr/include/c++/10/bits/stl_map.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class multimap; # 98 "/usr/include/c++/10/bits/stl_map.h" 3 template , typename _Alloc = std::allocator > > class map { public: typedef _Key key_type; typedef _Tp mapped_type; typedef std::pair value_type; typedef _Compare key_compare; typedef _Alloc allocator_type; private: # 123 "/usr/include/c++/10/bits/stl_map.h" 3 static_assert(is_same::value, "std::map must have the same value_type as its allocator"); public: class value_compare : public std::binary_function { friend class map<_Key, _Tp, _Compare, _Alloc>; protected: _Compare comp; value_compare(_Compare __c) : comp(__c) { } public: bool operator()(const value_type& __x, const value_type& __y) const { return comp(__x.first, __y.first); } }; private: typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind::other _Pair_alloc_type; typedef _Rb_tree, key_compare, _Pair_alloc_type> _Rep_type; _Rep_type _M_t; typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; public: typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Rep_type::iterator iterator; typedef typename _Rep_type::const_iterator const_iterator; typedef typename _Rep_type::size_type size_type; typedef typename _Rep_type::difference_type difference_type; typedef typename _Rep_type::reverse_iterator reverse_iterator; typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; using node_type = typename _Rep_type::node_type; using insert_return_type = typename _Rep_type::insert_return_type; # 185 "/usr/include/c++/10/bits/stl_map.h" 3 map() = default; explicit map(const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Pair_alloc_type(__a)) { } # 207 "/usr/include/c++/10/bits/stl_map.h" 3 map(const map&) = default; map(map&&) = default; # 228 "/usr/include/c++/10/bits/stl_map.h" 3 map(initializer_list __l, const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) : _M_t(__comp, _Pair_alloc_type(__a)) { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } explicit map(const allocator_type& __a) : _M_t(_Pair_alloc_type(__a)) { } map(const map& __m, const allocator_type& __a) : _M_t(__m._M_t, _Pair_alloc_type(__a)) { } map(map&& __m, const allocator_type& __a) noexcept(is_nothrow_copy_constructible<_Compare>::value && _Alloc_traits::_S_always_equal()) : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { } map(initializer_list __l, const allocator_type& __a) : _M_t(_Pair_alloc_type(__a)) { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } template map(_InputIterator __first, _InputIterator __last, const allocator_type& __a) : _M_t(_Pair_alloc_type(__a)) { _M_t._M_insert_range_unique(__first, __last); } # 272 "/usr/include/c++/10/bits/stl_map.h" 3 template map(_InputIterator __first, _InputIterator __last) : _M_t() { _M_t._M_insert_range_unique(__first, __last); } # 289 "/usr/include/c++/10/bits/stl_map.h" 3 template map(_InputIterator __first, _InputIterator __last, const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Pair_alloc_type(__a)) { _M_t._M_insert_range_unique(__first, __last); } ~map() = default; # 318 "/usr/include/c++/10/bits/stl_map.h" 3 map& operator=(const map&) = default; map& operator=(map&&) = default; # 336 "/usr/include/c++/10/bits/stl_map.h" 3 map& operator=(initializer_list __l) { _M_t._M_assign_unique(__l.begin(), __l.end()); return *this; } allocator_type get_allocator() const noexcept { return allocator_type(_M_t.get_allocator()); } iterator begin() noexcept { return _M_t.begin(); } const_iterator begin() const noexcept { return _M_t.begin(); } iterator end() noexcept { return _M_t.end(); } const_iterator end() const noexcept { return _M_t.end(); } reverse_iterator rbegin() noexcept { return _M_t.rbegin(); } const_reverse_iterator rbegin() const noexcept { return _M_t.rbegin(); } reverse_iterator rend() noexcept { return _M_t.rend(); } const_reverse_iterator rend() const noexcept { return _M_t.rend(); } const_iterator cbegin() const noexcept { return _M_t.begin(); } const_iterator cend() const noexcept { return _M_t.end(); } const_reverse_iterator crbegin() const noexcept { return _M_t.rbegin(); } const_reverse_iterator crend() const noexcept { return _M_t.rend(); } [[__nodiscard__]] bool empty() const noexcept { return _M_t.empty(); } size_type size() const noexcept { return _M_t.size(); } size_type max_size() const noexcept { return _M_t.max_size(); } # 491 "/usr/include/c++/10/bits/stl_map.h" 3 mapped_type& operator[](const key_type& __k) { iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct, std::tuple(__k), std::tuple<>()); return (*__i).second; } mapped_type& operator[](key_type&& __k) { iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::tuple<>()); return (*__i).second; } # 536 "/usr/include/c++/10/bits/stl_map.h" 3 mapped_type& at(const key_type& __k) { iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) __throw_out_of_range(("map::at")); return (*__i).second; } const mapped_type& at(const key_type& __k) const { const_iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) __throw_out_of_range(("map::at")); return (*__i).second; } # 574 "/usr/include/c++/10/bits/stl_map.h" 3 template std::pair emplace(_Args&&... __args) { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); } # 604 "/usr/include/c++/10/bits/stl_map.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_t._M_emplace_hint_unique(__pos, std::forward<_Args>(__args)...); } node_type extract(const_iterator __pos) { ; return _M_t.extract(__pos); } node_type extract(const key_type& __x) { return _M_t.extract(__x); } insert_return_type insert(node_type&& __nh) { return _M_t._M_reinsert_node_unique(std::move(__nh)); } iterator insert(const_iterator __hint, node_type&& __nh) { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); } template friend class std::_Rb_tree_merge_helper; template void merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); } template void merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source) { merge(__source); } template void merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); } template void merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source) { merge(__source); } # 689 "/usr/include/c++/10/bits/stl_map.h" 3 template pair try_emplace(const key_type& __k, _Args&&... __args) { iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) { __i = emplace_hint(__i, std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple( std::forward<_Args>(__args)...)); return {__i, true}; } return {__i, false}; } template pair try_emplace(key_type&& __k, _Args&&... __args) { iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) { __i = emplace_hint(__i, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple( std::forward<_Args>(__args)...)); return {__i, true}; } return {__i, false}; } # 749 "/usr/include/c++/10/bits/stl_map.h" 3 template iterator try_emplace(const_iterator __hint, const key_type& __k, _Args&&... __args) { iterator __i; auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k); if (__true_hint.second) __i = emplace_hint(iterator(__true_hint.second), std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple( std::forward<_Args>(__args)...)); else __i = iterator(__true_hint.first); return __i; } template iterator try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args) { iterator __i; auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k); if (__true_hint.second) __i = emplace_hint(iterator(__true_hint.second), std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple( std::forward<_Args>(__args)...)); else __i = iterator(__true_hint.first); return __i; } # 802 "/usr/include/c++/10/bits/stl_map.h" 3 std::pair insert(const value_type& __x) { return _M_t._M_insert_unique(__x); } std::pair insert(value_type&& __x) { return _M_t._M_insert_unique(std::move(__x)); } template __enable_if_t::value, pair> insert(_Pair&& __x) { return _M_t._M_emplace_unique(std::forward<_Pair>(__x)); } # 829 "/usr/include/c++/10/bits/stl_map.h" 3 void insert(std::initializer_list __list) { insert(__list.begin(), __list.end()); } # 858 "/usr/include/c++/10/bits/stl_map.h" 3 iterator insert(const_iterator __position, const value_type& __x) { return _M_t._M_insert_unique_(__position, __x); } iterator insert(const_iterator __position, value_type&& __x) { return _M_t._M_insert_unique_(__position, std::move(__x)); } template __enable_if_t::value, iterator> insert(const_iterator __position, _Pair&& __x) { return _M_t._M_emplace_hint_unique(__position, std::forward<_Pair>(__x)); } # 891 "/usr/include/c++/10/bits/stl_map.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_t._M_insert_range_unique(__first, __last); } # 916 "/usr/include/c++/10/bits/stl_map.h" 3 template pair insert_or_assign(const key_type& __k, _Obj&& __obj) { iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) { __i = emplace_hint(__i, std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple( std::forward<_Obj>(__obj))); return {__i, true}; } (*__i).second = std::forward<_Obj>(__obj); return {__i, false}; } template pair insert_or_assign(key_type&& __k, _Obj&& __obj) { iterator __i = lower_bound(__k); if (__i == end() || key_comp()(__k, (*__i).first)) { __i = emplace_hint(__i, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple( std::forward<_Obj>(__obj))); return {__i, true}; } (*__i).second = std::forward<_Obj>(__obj); return {__i, false}; } # 971 "/usr/include/c++/10/bits/stl_map.h" 3 template iterator insert_or_assign(const_iterator __hint, const key_type& __k, _Obj&& __obj) { iterator __i; auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k); if (__true_hint.second) { return emplace_hint(iterator(__true_hint.second), std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple( std::forward<_Obj>(__obj))); } __i = iterator(__true_hint.first); (*__i).second = std::forward<_Obj>(__obj); return __i; } template iterator insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj) { iterator __i; auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k); if (__true_hint.second) { return emplace_hint(iterator(__true_hint.second), std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple( std::forward<_Obj>(__obj))); } __i = iterator(__true_hint.first); (*__i).second = std::forward<_Obj>(__obj); return __i; } # 1030 "/usr/include/c++/10/bits/stl_map.h" 3 iterator erase(const_iterator __position) { return _M_t.erase(__position); } __attribute ((__abi_tag__ ("cxx11"))) iterator erase(iterator __position) { return _M_t.erase(__position); } # 1067 "/usr/include/c++/10/bits/stl_map.h" 3 size_type erase(const key_type& __x) { return _M_t.erase(__x); } # 1087 "/usr/include/c++/10/bits/stl_map.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_t.erase(__first, __last); } # 1121 "/usr/include/c++/10/bits/stl_map.h" 3 void swap(map& __x) noexcept(__is_nothrow_swappable<_Compare>::value) { _M_t.swap(__x._M_t); } void clear() noexcept { _M_t.clear(); } key_compare key_comp() const { return _M_t.key_comp(); } value_compare value_comp() const { return value_compare(_M_t.key_comp()); } # 1168 "/usr/include/c++/10/bits/stl_map.h" 3 iterator find(const key_type& __x) { return _M_t.find(__x); } template auto find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x)) { return _M_t._M_find_tr(__x); } # 1193 "/usr/include/c++/10/bits/stl_map.h" 3 const_iterator find(const key_type& __x) const { return _M_t.find(__x); } template auto find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x)) { return _M_t._M_find_tr(__x); } # 1214 "/usr/include/c++/10/bits/stl_map.h" 3 size_type count(const key_type& __x) const { return _M_t.find(__x) == _M_t.end() ? 0 : 1; } template auto count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x)) { return _M_t._M_count_tr(__x); } # 1233 "/usr/include/c++/10/bits/stl_map.h" 3 bool contains(const key_type& __x) const { return _M_t.find(__x) != _M_t.end(); } template auto contains(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x), void(), true) { return _M_t._M_find_tr(__x) != _M_t.end(); } # 1257 "/usr/include/c++/10/bits/stl_map.h" 3 iterator lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); } template auto lower_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) { return iterator(_M_t._M_lower_bound_tr(__x)); } # 1282 "/usr/include/c++/10/bits/stl_map.h" 3 const_iterator lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); } template auto lower_bound(const _Kt& __x) const -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x))) { return const_iterator(_M_t._M_lower_bound_tr(__x)); } # 1302 "/usr/include/c++/10/bits/stl_map.h" 3 iterator upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); } template auto upper_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) { return iterator(_M_t._M_upper_bound_tr(__x)); } # 1322 "/usr/include/c++/10/bits/stl_map.h" 3 const_iterator upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); } template auto upper_bound(const _Kt& __x) const -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x))) { return const_iterator(_M_t._M_upper_bound_tr(__x)); } # 1351 "/usr/include/c++/10/bits/stl_map.h" 3 std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } template auto equal_range(const _Kt& __x) -> decltype(pair(_M_t._M_equal_range_tr(__x))) { return pair(_M_t._M_equal_range_tr(__x)); } # 1380 "/usr/include/c++/10/bits/stl_map.h" 3 std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } template auto equal_range(const _Kt& __x) const -> decltype(pair( _M_t._M_equal_range_tr(__x))) { return pair( _M_t._M_equal_range_tr(__x)); } template friend bool operator==(const map<_K1, _T1, _C1, _A1>&, const map<_K1, _T1, _C1, _A1>&); template friend __detail::__synth3way_t> operator<=>(const map<_K1, _T1, _C1, _A1>&, const map<_K1, _T1, _C1, _A1>&); }; template>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator()) -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Compare, _Allocator>; template, typename _Allocator = allocator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> map(initializer_list>, _Compare = _Compare(), _Allocator = _Allocator()) -> map<_Key, _Tp, _Compare, _Allocator>; template , typename = _RequireAllocator<_Allocator>> map(_InputIterator, _InputIterator, _Allocator) -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, less<__iter_key_t<_InputIterator>>, _Allocator>; template> map(initializer_list>, _Allocator) -> map<_Key, _Tp, less<_Key>, _Allocator>; # 1461 "/usr/include/c++/10/bits/stl_map.h" 3 template inline bool operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x, const map<_Key, _Tp, _Compare, _Alloc>& __y) { return __x._M_t == __y._M_t; } # 1482 "/usr/include/c++/10/bits/stl_map.h" 3 template inline __detail::__synth3way_t> operator<=>(const map<_Key, _Tp, _Compare, _Alloc>& __x, const map<_Key, _Tp, _Compare, _Alloc>& __y) { return __x._M_t <=> __y._M_t; } # 1535 "/usr/include/c++/10/bits/stl_map.h" 3 template inline void swap(map<_Key, _Tp, _Compare, _Alloc>& __x, map<_Key, _Tp, _Compare, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct _Rb_tree_merge_helper, _Cmp2> { private: friend class std::map<_Key, _Val, _Cmp1, _Alloc>; static auto& _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map) { return __map._M_t; } static auto& _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map) { return __map._M_t; } }; } # 62 "/usr/include/c++/10/map" 2 3 # 1 "/usr/include/c++/10/bits/stl_multimap.h" 1 3 # 64 "/usr/include/c++/10/bits/stl_multimap.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class map; # 96 "/usr/include/c++/10/bits/stl_multimap.h" 3 template , typename _Alloc = std::allocator > > class multimap { public: typedef _Key key_type; typedef _Tp mapped_type; typedef std::pair value_type; typedef _Compare key_compare; typedef _Alloc allocator_type; private: # 122 "/usr/include/c++/10/bits/stl_multimap.h" 3 static_assert(is_same::value, "std::multimap must have the same value_type as its allocator"); public: class value_compare : public std::binary_function { friend class multimap<_Key, _Tp, _Compare, _Alloc>; protected: _Compare comp; value_compare(_Compare __c) : comp(__c) { } public: bool operator()(const value_type& __x, const value_type& __y) const { return comp(__x.first, __y.first); } }; private: typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind::other _Pair_alloc_type; typedef _Rb_tree, key_compare, _Pair_alloc_type> _Rep_type; _Rep_type _M_t; typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; public: typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Rep_type::iterator iterator; typedef typename _Rep_type::const_iterator const_iterator; typedef typename _Rep_type::size_type size_type; typedef typename _Rep_type::difference_type difference_type; typedef typename _Rep_type::reverse_iterator reverse_iterator; typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; using node_type = typename _Rep_type::node_type; # 182 "/usr/include/c++/10/bits/stl_multimap.h" 3 multimap() = default; explicit multimap(const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Pair_alloc_type(__a)) { } # 204 "/usr/include/c++/10/bits/stl_multimap.h" 3 multimap(const multimap&) = default; # 213 "/usr/include/c++/10/bits/stl_multimap.h" 3 multimap(multimap&&) = default; # 225 "/usr/include/c++/10/bits/stl_multimap.h" 3 multimap(initializer_list __l, const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) : _M_t(__comp, _Pair_alloc_type(__a)) { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } explicit multimap(const allocator_type& __a) : _M_t(_Pair_alloc_type(__a)) { } multimap(const multimap& __m, const allocator_type& __a) : _M_t(__m._M_t, _Pair_alloc_type(__a)) { } multimap(multimap&& __m, const allocator_type& __a) noexcept(is_nothrow_copy_constructible<_Compare>::value && _Alloc_traits::_S_always_equal()) : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { } multimap(initializer_list __l, const allocator_type& __a) : _M_t(_Pair_alloc_type(__a)) { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } template multimap(_InputIterator __first, _InputIterator __last, const allocator_type& __a) : _M_t(_Pair_alloc_type(__a)) { _M_t._M_insert_range_equal(__first, __last); } # 268 "/usr/include/c++/10/bits/stl_multimap.h" 3 template multimap(_InputIterator __first, _InputIterator __last) : _M_t() { _M_t._M_insert_range_equal(__first, __last); } # 284 "/usr/include/c++/10/bits/stl_multimap.h" 3 template multimap(_InputIterator __first, _InputIterator __last, const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Pair_alloc_type(__a)) { _M_t._M_insert_range_equal(__first, __last); } ~multimap() = default; # 313 "/usr/include/c++/10/bits/stl_multimap.h" 3 multimap& operator=(const multimap&) = default; multimap& operator=(multimap&&) = default; # 331 "/usr/include/c++/10/bits/stl_multimap.h" 3 multimap& operator=(initializer_list __l) { _M_t._M_assign_equal(__l.begin(), __l.end()); return *this; } allocator_type get_allocator() const noexcept { return allocator_type(_M_t.get_allocator()); } iterator begin() noexcept { return _M_t.begin(); } const_iterator begin() const noexcept { return _M_t.begin(); } iterator end() noexcept { return _M_t.end(); } const_iterator end() const noexcept { return _M_t.end(); } reverse_iterator rbegin() noexcept { return _M_t.rbegin(); } const_reverse_iterator rbegin() const noexcept { return _M_t.rbegin(); } reverse_iterator rend() noexcept { return _M_t.rend(); } const_reverse_iterator rend() const noexcept { return _M_t.rend(); } const_iterator cbegin() const noexcept { return _M_t.begin(); } const_iterator cend() const noexcept { return _M_t.end(); } const_reverse_iterator crbegin() const noexcept { return _M_t.rbegin(); } const_reverse_iterator crend() const noexcept { return _M_t.rend(); } [[__nodiscard__]] bool empty() const noexcept { return _M_t.empty(); } size_type size() const noexcept { return _M_t.size(); } size_type max_size() const noexcept { return _M_t.max_size(); } # 489 "/usr/include/c++/10/bits/stl_multimap.h" 3 template iterator emplace(_Args&&... __args) { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); } # 516 "/usr/include/c++/10/bits/stl_multimap.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_t._M_emplace_hint_equal(__pos, std::forward<_Args>(__args)...); } # 538 "/usr/include/c++/10/bits/stl_multimap.h" 3 iterator insert(const value_type& __x) { return _M_t._M_insert_equal(__x); } iterator insert(value_type&& __x) { return _M_t._M_insert_equal(std::move(__x)); } template __enable_if_t::value, iterator> insert(_Pair&& __x) { return _M_t._M_emplace_equal(std::forward<_Pair>(__x)); } # 577 "/usr/include/c++/10/bits/stl_multimap.h" 3 iterator insert(const_iterator __position, const value_type& __x) { return _M_t._M_insert_equal_(__position, __x); } iterator insert(const_iterator __position, value_type&& __x) { return _M_t._M_insert_equal_(__position, std::move(__x)); } template __enable_if_t::value, iterator> insert(const_iterator __position, _Pair&& __x) { return _M_t._M_emplace_hint_equal(__position, std::forward<_Pair>(__x)); } # 611 "/usr/include/c++/10/bits/stl_multimap.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_t._M_insert_range_equal(__first, __last); } # 624 "/usr/include/c++/10/bits/stl_multimap.h" 3 void insert(initializer_list __l) { this->insert(__l.begin(), __l.end()); } node_type extract(const_iterator __pos) { ; return _M_t.extract(__pos); } node_type extract(const key_type& __x) { return _M_t.extract(__x); } iterator insert(node_type&& __nh) { return _M_t._M_reinsert_node_equal(std::move(__nh)); } iterator insert(const_iterator __hint, node_type&& __nh) { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); } template friend class std::_Rb_tree_merge_helper; template void merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); } template void merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source) { merge(__source); } template void merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); } template void merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source) { merge(__source); } # 701 "/usr/include/c++/10/bits/stl_multimap.h" 3 iterator erase(const_iterator __position) { return _M_t.erase(__position); } __attribute ((__abi_tag__ ("cxx11"))) iterator erase(iterator __position) { return _M_t.erase(__position); } # 738 "/usr/include/c++/10/bits/stl_multimap.h" 3 size_type erase(const key_type& __x) { return _M_t.erase(__x); } # 759 "/usr/include/c++/10/bits/stl_multimap.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_t.erase(__first, __last); } # 796 "/usr/include/c++/10/bits/stl_multimap.h" 3 void swap(multimap& __x) noexcept(__is_nothrow_swappable<_Compare>::value) { _M_t.swap(__x._M_t); } void clear() noexcept { _M_t.clear(); } key_compare key_comp() const { return _M_t.key_comp(); } value_compare value_comp() const { return value_compare(_M_t.key_comp()); } # 842 "/usr/include/c++/10/bits/stl_multimap.h" 3 iterator find(const key_type& __x) { return _M_t.find(__x); } template auto find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x)) { return _M_t._M_find_tr(__x); } # 866 "/usr/include/c++/10/bits/stl_multimap.h" 3 const_iterator find(const key_type& __x) const { return _M_t.find(__x); } template auto find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x)) { return _M_t._M_find_tr(__x); } # 884 "/usr/include/c++/10/bits/stl_multimap.h" 3 size_type count(const key_type& __x) const { return _M_t.count(__x); } template auto count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x)) { return _M_t._M_count_tr(__x); } # 903 "/usr/include/c++/10/bits/stl_multimap.h" 3 bool contains(const key_type& __x) const { return _M_t.find(__x) != _M_t.end(); } template auto contains(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x), void(), true) { return _M_t._M_find_tr(__x) != _M_t.end(); } # 927 "/usr/include/c++/10/bits/stl_multimap.h" 3 iterator lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); } template auto lower_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) { return iterator(_M_t._M_lower_bound_tr(__x)); } # 952 "/usr/include/c++/10/bits/stl_multimap.h" 3 const_iterator lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); } template auto lower_bound(const _Kt& __x) const -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x))) { return const_iterator(_M_t._M_lower_bound_tr(__x)); } # 972 "/usr/include/c++/10/bits/stl_multimap.h" 3 iterator upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); } template auto upper_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) { return iterator(_M_t._M_upper_bound_tr(__x)); } # 992 "/usr/include/c++/10/bits/stl_multimap.h" 3 const_iterator upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); } template auto upper_bound(const _Kt& __x) const -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x))) { return const_iterator(_M_t._M_upper_bound_tr(__x)); } # 1019 "/usr/include/c++/10/bits/stl_multimap.h" 3 std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } template auto equal_range(const _Kt& __x) -> decltype(pair(_M_t._M_equal_range_tr(__x))) { return pair(_M_t._M_equal_range_tr(__x)); } # 1046 "/usr/include/c++/10/bits/stl_multimap.h" 3 std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } template auto equal_range(const _Kt& __x) const -> decltype(pair( _M_t._M_equal_range_tr(__x))) { return pair( _M_t._M_equal_range_tr(__x)); } template friend bool operator==(const multimap<_K1, _T1, _C1, _A1>&, const multimap<_K1, _T1, _C1, _A1>&); template friend __detail::__synth3way_t> operator<=>(const multimap<_K1, _T1, _C1, _A1>&, const multimap<_K1, _T1, _C1, _A1>&); }; template>, typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator()) -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, _Compare, _Allocator>; template, typename _Allocator = allocator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> multimap(initializer_list>, _Compare = _Compare(), _Allocator = _Allocator()) -> multimap<_Key, _Tp, _Compare, _Allocator>; template, typename = _RequireAllocator<_Allocator>> multimap(_InputIterator, _InputIterator, _Allocator) -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>, less<__iter_key_t<_InputIterator>>, _Allocator>; template> multimap(initializer_list>, _Allocator) -> multimap<_Key, _Tp, less<_Key>, _Allocator>; # 1126 "/usr/include/c++/10/bits/stl_multimap.h" 3 template inline bool operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, const multimap<_Key, _Tp, _Compare, _Alloc>& __y) { return __x._M_t == __y._M_t; } # 1147 "/usr/include/c++/10/bits/stl_multimap.h" 3 template inline __detail::__synth3way_t> operator<=>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, const multimap<_Key, _Tp, _Compare, _Alloc>& __y) { return __x._M_t <=> __y._M_t; } # 1200 "/usr/include/c++/10/bits/stl_multimap.h" 3 template inline void swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x, multimap<_Key, _Tp, _Compare, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct _Rb_tree_merge_helper, _Cmp2> { private: friend class std::multimap<_Key, _Val, _Cmp1, _Alloc>; static auto& _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map) { return __map._M_t; } static auto& _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map) { return __map._M_t; } }; } # 63 "/usr/include/c++/10/map" 2 3 # 71 "/usr/include/c++/10/map" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template> using map = std::map<_Key, _Tp, _Cmp, polymorphic_allocator>>; template> using multimap = std::multimap<_Key, _Tp, _Cmp, polymorphic_allocator>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename map<_Key, _Tp, _Compare, _Alloc>::size_type erase_if(map<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } template inline typename multimap<_Key, _Tp, _Compare, _Alloc>::size_type erase_if(multimap<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } } # 60 "all-std.cxx" 2 # 1 "/usr/include/c++/10/queue" 1 3 # 58 "/usr/include/c++/10/queue" 3 # 59 "/usr/include/c++/10/queue" 3 # 1 "/usr/include/c++/10/bits/stl_queue.h" 1 3 # 65 "/usr/include/c++/10/bits/stl_queue.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 95 "/usr/include/c++/10/bits/stl_queue.h" 3 template > class queue { # 109 "/usr/include/c++/10/bits/stl_queue.h" 3 template friend bool operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); template friend bool operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); template friend compare_three_way_result_t<_Seq1> operator<=>(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); template using _Uses = typename enable_if::value>::type; static_assert(is_same<_Tp, typename _Sequence::value_type>::value, "value_type must be the same as the underlying container"); public: typedef typename _Sequence::value_type value_type; typedef typename _Sequence::reference reference; typedef typename _Sequence::const_reference const_reference; typedef typename _Sequence::size_type size_type; typedef _Sequence container_type; protected: # 153 "/usr/include/c++/10/bits/stl_queue.h" 3 _Sequence c; public: # 164 "/usr/include/c++/10/bits/stl_queue.h" 3 template::value>::type> queue() : c() { } explicit queue(const _Sequence& __c) : c(__c) { } explicit queue(_Sequence&& __c) : c(std::move(__c)) { } template> explicit queue(const _Alloc& __a) : c(__a) { } template> queue(const _Sequence& __c, const _Alloc& __a) : c(__c, __a) { } template> queue(_Sequence&& __c, const _Alloc& __a) : c(std::move(__c), __a) { } template> queue(const queue& __q, const _Alloc& __a) : c(__q.c, __a) { } template> queue(queue&& __q, const _Alloc& __a) : c(std::move(__q.c), __a) { } [[__nodiscard__]] bool empty() const { return c.empty(); } size_type size() const { return c.size(); } reference front() { ; return c.front(); } const_reference front() const { ; return c.front(); } reference back() { ; return c.back(); } const_reference back() const { ; return c.back(); } # 264 "/usr/include/c++/10/bits/stl_queue.h" 3 void push(const value_type& __x) { c.push_back(__x); } void push(value_type&& __x) { c.push_back(std::move(__x)); } template decltype(auto) emplace(_Args&&... __args) { return c.emplace_back(std::forward<_Args>(__args)...); } # 297 "/usr/include/c++/10/bits/stl_queue.h" 3 void pop() { ; c.pop_front(); } void swap(queue& __q) noexcept(__is_nothrow_swappable<_Sequence>::value) { using std::swap; swap(c, __q.c); } }; template> queue(_Container) -> queue; template, typename = _RequireAllocator<_Allocator>> queue(_Container, _Allocator) -> queue; # 342 "/usr/include/c++/10/bits/stl_queue.h" 3 template inline bool operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) { return __x.c == __y.c; } # 360 "/usr/include/c++/10/bits/stl_queue.h" 3 template inline bool operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) { return __x.c < __y.c; } template inline bool operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) { return !(__x == __y); } template inline bool operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) { return __y < __x; } template inline bool operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) { return !(__y < __x); } template inline bool operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) { return !(__x < __y); } template inline compare_three_way_result_t<_Seq> operator<=>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) { return __x.c <=> __y.c; } template inline typename enable_if<__is_swappable<_Seq>::value>::type swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct uses_allocator, _Alloc> : public uses_allocator<_Seq, _Alloc>::type { }; # 454 "/usr/include/c++/10/bits/stl_queue.h" 3 template, typename _Compare = less > class priority_queue { # 472 "/usr/include/c++/10/bits/stl_queue.h" 3 template using _Uses = typename enable_if::value>::type; static_assert(is_same<_Tp, typename _Sequence::value_type>::value, "value_type must be the same as the underlying container"); public: typedef typename _Sequence::value_type value_type; typedef typename _Sequence::reference reference; typedef typename _Sequence::const_reference const_reference; typedef typename _Sequence::size_type size_type; typedef _Sequence container_type; typedef _Compare value_compare; protected: _Sequence c; _Compare comp; public: # 511 "/usr/include/c++/10/bits/stl_queue.h" 3 template, is_default_constructible<_Seq>>::value>::type> priority_queue() : c(), comp() { } explicit priority_queue(const _Compare& __x, const _Sequence& __s) : c(__s), comp(__x) { std::make_heap(c.begin(), c.end(), comp); } explicit priority_queue(const _Compare& __x, _Sequence&& __s = _Sequence()) : c(std::move(__s)), comp(__x) { std::make_heap(c.begin(), c.end(), comp); } template> explicit priority_queue(const _Alloc& __a) : c(__a), comp() { } template> priority_queue(const _Compare& __x, const _Alloc& __a) : c(__a), comp(__x) { } template> priority_queue(const _Compare& __x, const _Sequence& __c, const _Alloc& __a) : c(__c, __a), comp(__x) { std::make_heap(c.begin(), c.end(), comp); } template> priority_queue(const _Compare& __x, _Sequence&& __c, const _Alloc& __a) : c(std::move(__c), __a), comp(__x) { std::make_heap(c.begin(), c.end(), comp); } template> priority_queue(const priority_queue& __q, const _Alloc& __a) : c(__q.c, __a), comp(__q.comp) { } template> priority_queue(priority_queue&& __q, const _Alloc& __a) : c(std::move(__q.c), __a), comp(std::move(__q.comp)) { } # 585 "/usr/include/c++/10/bits/stl_queue.h" 3 template priority_queue(_InputIterator __first, _InputIterator __last, const _Compare& __x, const _Sequence& __s) : c(__s), comp(__x) { ; c.insert(c.end(), __first, __last); std::make_heap(c.begin(), c.end(), comp); } template priority_queue(_InputIterator __first, _InputIterator __last, const _Compare& __x = _Compare(), _Sequence&& __s = _Sequence()) : c(std::move(__s)), comp(__x) { ; c.insert(c.end(), __first, __last); std::make_heap(c.begin(), c.end(), comp); } [[__nodiscard__]] bool empty() const { return c.empty(); } size_type size() const { return c.size(); } const_reference top() const { ; return c.front(); } # 639 "/usr/include/c++/10/bits/stl_queue.h" 3 void push(const value_type& __x) { c.push_back(__x); std::push_heap(c.begin(), c.end(), comp); } void push(value_type&& __x) { c.push_back(std::move(__x)); std::push_heap(c.begin(), c.end(), comp); } template void emplace(_Args&&... __args) { c.emplace_back(std::forward<_Args>(__args)...); std::push_heap(c.begin(), c.end(), comp); } # 674 "/usr/include/c++/10/bits/stl_queue.h" 3 void pop() { ; std::pop_heap(c.begin(), c.end(), comp); c.pop_back(); } void swap(priority_queue& __pq) noexcept(__and_< __is_nothrow_swappable<_Sequence>, __is_nothrow_swappable<_Compare> >::value) { using std::swap; swap(c, __pq.c); swap(comp, __pq.comp); } }; template, typename = _RequireNotAllocator<_Container>> priority_queue(_Compare, _Container) -> priority_queue; template::value_type, typename _Compare = less<_ValT>, typename _Container = vector<_ValT>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireNotAllocator<_Container>> priority_queue(_InputIterator, _InputIterator, _Compare = _Compare(), _Container = _Container()) -> priority_queue<_ValT, _Container, _Compare>; template, typename = _RequireNotAllocator<_Container>, typename = _RequireAllocator<_Allocator>> priority_queue(_Compare, _Container, _Allocator) -> priority_queue; template inline typename enable_if<__and_<__is_swappable<_Sequence>, __is_swappable<_Compare>>::value>::type swap(priority_queue<_Tp, _Sequence, _Compare>& __x, priority_queue<_Tp, _Sequence, _Compare>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct uses_allocator, _Alloc> : public uses_allocator<_Sequence, _Alloc>::type { }; } # 65 "/usr/include/c++/10/queue" 2 3 # 61 "all-std.cxx" 2 # 1 "/usr/include/c++/10/set" 1 3 # 58 "/usr/include/c++/10/set" 3 # 59 "/usr/include/c++/10/set" 3 # 1 "/usr/include/c++/10/bits/stl_set.h" 1 3 # 64 "/usr/include/c++/10/bits/stl_set.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class multiset; # 92 "/usr/include/c++/10/bits/stl_set.h" 3 template, typename _Alloc = std::allocator<_Key> > class set { # 108 "/usr/include/c++/10/bits/stl_set.h" 3 static_assert(is_same::type, _Key>::value, "std::set must have a non-const, non-volatile value_type"); static_assert(is_same::value, "std::set must have the same value_type as its allocator"); public: typedef _Key key_type; typedef _Key value_type; typedef _Compare key_compare; typedef _Compare value_compare; typedef _Alloc allocator_type; private: typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Key>::other _Key_alloc_type; typedef _Rb_tree, key_compare, _Key_alloc_type> _Rep_type; _Rep_type _M_t; typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits; public: typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Rep_type::const_iterator iterator; typedef typename _Rep_type::const_iterator const_iterator; typedef typename _Rep_type::const_reverse_iterator reverse_iterator; typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; typedef typename _Rep_type::size_type size_type; typedef typename _Rep_type::difference_type difference_type; using node_type = typename _Rep_type::node_type; using insert_return_type = typename _Rep_type::insert_return_type; # 167 "/usr/include/c++/10/bits/stl_set.h" 3 set() = default; explicit set(const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Key_alloc_type(__a)) { } # 190 "/usr/include/c++/10/bits/stl_set.h" 3 template set(_InputIterator __first, _InputIterator __last) : _M_t() { _M_t._M_insert_range_unique(__first, __last); } # 207 "/usr/include/c++/10/bits/stl_set.h" 3 template set(_InputIterator __first, _InputIterator __last, const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Key_alloc_type(__a)) { _M_t._M_insert_range_unique(__first, __last); } # 223 "/usr/include/c++/10/bits/stl_set.h" 3 set(const set&) = default; set(set&&) = default; # 243 "/usr/include/c++/10/bits/stl_set.h" 3 set(initializer_list __l, const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) : _M_t(__comp, _Key_alloc_type(__a)) { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } explicit set(const allocator_type& __a) : _M_t(_Key_alloc_type(__a)) { } set(const set& __x, const allocator_type& __a) : _M_t(__x._M_t, _Key_alloc_type(__a)) { } set(set&& __x, const allocator_type& __a) noexcept(is_nothrow_copy_constructible<_Compare>::value && _Alloc_traits::_S_always_equal()) : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { } set(initializer_list __l, const allocator_type& __a) : _M_t(_Key_alloc_type(__a)) { _M_t._M_insert_range_unique(__l.begin(), __l.end()); } template set(_InputIterator __first, _InputIterator __last, const allocator_type& __a) : _M_t(_Key_alloc_type(__a)) { _M_t._M_insert_range_unique(__first, __last); } ~set() = default; # 297 "/usr/include/c++/10/bits/stl_set.h" 3 set& operator=(const set&) = default; set& operator=(set&&) = default; # 315 "/usr/include/c++/10/bits/stl_set.h" 3 set& operator=(initializer_list __l) { _M_t._M_assign_unique(__l.begin(), __l.end()); return *this; } key_compare key_comp() const { return _M_t.key_comp(); } value_compare value_comp() const { return _M_t.key_comp(); } allocator_type get_allocator() const noexcept { return allocator_type(_M_t.get_allocator()); } iterator begin() const noexcept { return _M_t.begin(); } iterator end() const noexcept { return _M_t.end(); } reverse_iterator rbegin() const noexcept { return _M_t.rbegin(); } reverse_iterator rend() const noexcept { return _M_t.rend(); } iterator cbegin() const noexcept { return _M_t.begin(); } iterator cend() const noexcept { return _M_t.end(); } reverse_iterator crbegin() const noexcept { return _M_t.rbegin(); } reverse_iterator crend() const noexcept { return _M_t.rend(); } [[__nodiscard__]] bool empty() const noexcept { return _M_t.empty(); } size_type size() const noexcept { return _M_t.size(); } size_type max_size() const noexcept { return _M_t.max_size(); } # 440 "/usr/include/c++/10/bits/stl_set.h" 3 void swap(set& __x) noexcept(__is_nothrow_swappable<_Compare>::value) { _M_t.swap(__x._M_t); } # 460 "/usr/include/c++/10/bits/stl_set.h" 3 template std::pair emplace(_Args&&... __args) { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); } # 486 "/usr/include/c++/10/bits/stl_set.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_t._M_emplace_hint_unique(__pos, std::forward<_Args>(__args)...); } # 508 "/usr/include/c++/10/bits/stl_set.h" 3 std::pair insert(const value_type& __x) { std::pair __p = _M_t._M_insert_unique(__x); return std::pair(__p.first, __p.second); } std::pair insert(value_type&& __x) { std::pair __p = _M_t._M_insert_unique(std::move(__x)); return std::pair(__p.first, __p.second); } # 545 "/usr/include/c++/10/bits/stl_set.h" 3 iterator insert(const_iterator __position, const value_type& __x) { return _M_t._M_insert_unique_(__position, __x); } iterator insert(const_iterator __position, value_type&& __x) { return _M_t._M_insert_unique_(__position, std::move(__x)); } # 564 "/usr/include/c++/10/bits/stl_set.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_t._M_insert_range_unique(__first, __last); } # 577 "/usr/include/c++/10/bits/stl_set.h" 3 void insert(initializer_list __l) { this->insert(__l.begin(), __l.end()); } node_type extract(const_iterator __pos) { ; return _M_t.extract(__pos); } node_type extract(const key_type& __x) { return _M_t.extract(__x); } insert_return_type insert(node_type&& __nh) { return _M_t._M_reinsert_node_unique(std::move(__nh)); } iterator insert(const_iterator __hint, node_type&& __nh) { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); } template friend class std::_Rb_tree_merge_helper; template void merge(set<_Key, _Compare1, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); } template void merge(set<_Key, _Compare1, _Alloc>&& __source) { merge(__source); } template void merge(multiset<_Key, _Compare1, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source)); } template void merge(multiset<_Key, _Compare1, _Alloc>&& __source) { merge(__source); } # 652 "/usr/include/c++/10/bits/stl_set.h" 3 __attribute ((__abi_tag__ ("cxx11"))) iterator erase(const_iterator __position) { return _M_t.erase(__position); } # 683 "/usr/include/c++/10/bits/stl_set.h" 3 size_type erase(const key_type& __x) { return _M_t.erase(__x); } # 704 "/usr/include/c++/10/bits/stl_set.h" 3 __attribute ((__abi_tag__ ("cxx11"))) iterator erase(const_iterator __first, const_iterator __last) { return _M_t.erase(__first, __last); } # 732 "/usr/include/c++/10/bits/stl_set.h" 3 void clear() noexcept { _M_t.clear(); } # 747 "/usr/include/c++/10/bits/stl_set.h" 3 size_type count(const key_type& __x) const { return _M_t.find(__x) == _M_t.end() ? 0 : 1; } template auto count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x)) { return _M_t._M_count_tr(__x); } # 767 "/usr/include/c++/10/bits/stl_set.h" 3 bool contains(const key_type& __x) const { return _M_t.find(__x) != _M_t.end(); } template auto contains(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x), void(), true) { return _M_t._M_find_tr(__x) != _M_t.end(); } # 793 "/usr/include/c++/10/bits/stl_set.h" 3 iterator find(const key_type& __x) { return _M_t.find(__x); } const_iterator find(const key_type& __x) const { return _M_t.find(__x); } template auto find(const _Kt& __x) -> decltype(iterator{_M_t._M_find_tr(__x)}) { return iterator{_M_t._M_find_tr(__x)}; } template auto find(const _Kt& __x) const -> decltype(const_iterator{_M_t._M_find_tr(__x)}) { return const_iterator{_M_t._M_find_tr(__x)}; } # 828 "/usr/include/c++/10/bits/stl_set.h" 3 iterator lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); } const_iterator lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); } template auto lower_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) { return iterator(_M_t._M_lower_bound_tr(__x)); } template auto lower_bound(const _Kt& __x) const -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x))) { return const_iterator(_M_t._M_lower_bound_tr(__x)); } # 858 "/usr/include/c++/10/bits/stl_set.h" 3 iterator upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); } const_iterator upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); } template auto upper_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) { return iterator(_M_t._M_upper_bound_tr(__x)); } template auto upper_bound(const _Kt& __x) const -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) { return const_iterator(_M_t._M_upper_bound_tr(__x)); } # 897 "/usr/include/c++/10/bits/stl_set.h" 3 std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } template auto equal_range(const _Kt& __x) -> decltype(pair(_M_t._M_equal_range_tr(__x))) { return pair(_M_t._M_equal_range_tr(__x)); } template auto equal_range(const _Kt& __x) const -> decltype(pair(_M_t._M_equal_range_tr(__x))) { return pair(_M_t._M_equal_range_tr(__x)); } template friend bool operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); template friend __detail::__synth3way_t<_K1> operator<=>(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); }; template::value_type>, typename _Allocator = allocator::value_type>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> set(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator()) -> set::value_type, _Compare, _Allocator>; template, typename _Allocator = allocator<_Key>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> set(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator()) -> set<_Key, _Compare, _Allocator>; template, typename = _RequireAllocator<_Allocator>> set(_InputIterator, _InputIterator, _Allocator) -> set::value_type, less::value_type>, _Allocator>; template> set(initializer_list<_Key>, _Allocator) -> set<_Key, less<_Key>, _Allocator>; # 983 "/usr/include/c++/10/bits/stl_set.h" 3 template inline bool operator==(const set<_Key, _Compare, _Alloc>& __x, const set<_Key, _Compare, _Alloc>& __y) { return __x._M_t == __y._M_t; } # 1004 "/usr/include/c++/10/bits/stl_set.h" 3 template inline __detail::__synth3way_t<_Key> operator<=>(const set<_Key, _Compare, _Alloc>& __x, const set<_Key, _Compare, _Alloc>& __y) { return __x._M_t <=> __y._M_t; } # 1057 "/usr/include/c++/10/bits/stl_set.h" 3 template inline void swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct _Rb_tree_merge_helper, _Cmp2> { private: friend class std::set<_Val, _Cmp1, _Alloc>; static auto& _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set) { return __set._M_t; } static auto& _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set) { return __set._M_t; } }; } # 62 "/usr/include/c++/10/set" 2 3 # 1 "/usr/include/c++/10/bits/stl_multiset.h" 1 3 # 64 "/usr/include/c++/10/bits/stl_multiset.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class set; # 94 "/usr/include/c++/10/bits/stl_multiset.h" 3 template , typename _Alloc = std::allocator<_Key> > class multiset { # 110 "/usr/include/c++/10/bits/stl_multiset.h" 3 static_assert(is_same::type, _Key>::value, "std::multiset must have a non-const, non-volatile value_type"); static_assert(is_same::value, "std::multiset must have the same value_type as its allocator"); public: typedef _Key key_type; typedef _Key value_type; typedef _Compare key_compare; typedef _Compare value_compare; typedef _Alloc allocator_type; private: typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Key>::other _Key_alloc_type; typedef _Rb_tree, key_compare, _Key_alloc_type> _Rep_type; _Rep_type _M_t; typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits; public: typedef typename _Alloc_traits::pointer pointer; typedef typename _Alloc_traits::const_pointer const_pointer; typedef typename _Alloc_traits::reference reference; typedef typename _Alloc_traits::const_reference const_reference; typedef typename _Rep_type::const_iterator iterator; typedef typename _Rep_type::const_iterator const_iterator; typedef typename _Rep_type::const_reverse_iterator reverse_iterator; typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; typedef typename _Rep_type::size_type size_type; typedef typename _Rep_type::difference_type difference_type; using node_type = typename _Rep_type::node_type; # 164 "/usr/include/c++/10/bits/stl_multiset.h" 3 multiset() = default; explicit multiset(const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Key_alloc_type(__a)) { } # 186 "/usr/include/c++/10/bits/stl_multiset.h" 3 template multiset(_InputIterator __first, _InputIterator __last) : _M_t() { _M_t._M_insert_range_equal(__first, __last); } # 202 "/usr/include/c++/10/bits/stl_multiset.h" 3 template multiset(_InputIterator __first, _InputIterator __last, const _Compare& __comp, const allocator_type& __a = allocator_type()) : _M_t(__comp, _Key_alloc_type(__a)) { _M_t._M_insert_range_equal(__first, __last); } # 218 "/usr/include/c++/10/bits/stl_multiset.h" 3 multiset(const multiset&) = default; # 227 "/usr/include/c++/10/bits/stl_multiset.h" 3 multiset(multiset&&) = default; # 239 "/usr/include/c++/10/bits/stl_multiset.h" 3 multiset(initializer_list __l, const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) : _M_t(__comp, _Key_alloc_type(__a)) { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } explicit multiset(const allocator_type& __a) : _M_t(_Key_alloc_type(__a)) { } multiset(const multiset& __m, const allocator_type& __a) : _M_t(__m._M_t, _Key_alloc_type(__a)) { } multiset(multiset&& __m, const allocator_type& __a) noexcept(is_nothrow_copy_constructible<_Compare>::value && _Alloc_traits::_S_always_equal()) : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { } multiset(initializer_list __l, const allocator_type& __a) : _M_t(_Key_alloc_type(__a)) { _M_t._M_insert_range_equal(__l.begin(), __l.end()); } template multiset(_InputIterator __first, _InputIterator __last, const allocator_type& __a) : _M_t(_Key_alloc_type(__a)) { _M_t._M_insert_range_equal(__first, __last); } ~multiset() = default; # 293 "/usr/include/c++/10/bits/stl_multiset.h" 3 multiset& operator=(const multiset&) = default; multiset& operator=(multiset&&) = default; # 311 "/usr/include/c++/10/bits/stl_multiset.h" 3 multiset& operator=(initializer_list __l) { _M_t._M_assign_equal(__l.begin(), __l.end()); return *this; } key_compare key_comp() const { return _M_t.key_comp(); } value_compare value_comp() const { return _M_t.key_comp(); } allocator_type get_allocator() const noexcept { return allocator_type(_M_t.get_allocator()); } iterator begin() const noexcept { return _M_t.begin(); } iterator end() const noexcept { return _M_t.end(); } reverse_iterator rbegin() const noexcept { return _M_t.rbegin(); } reverse_iterator rend() const noexcept { return _M_t.rend(); } iterator cbegin() const noexcept { return _M_t.begin(); } iterator cend() const noexcept { return _M_t.end(); } reverse_iterator crbegin() const noexcept { return _M_t.rbegin(); } reverse_iterator crend() const noexcept { return _M_t.rend(); } [[__nodiscard__]] bool empty() const noexcept { return _M_t.empty(); } size_type size() const noexcept { return _M_t.size(); } size_type max_size() const noexcept { return _M_t.max_size(); } # 436 "/usr/include/c++/10/bits/stl_multiset.h" 3 void swap(multiset& __x) noexcept(__is_nothrow_swappable<_Compare>::value) { _M_t.swap(__x._M_t); } # 455 "/usr/include/c++/10/bits/stl_multiset.h" 3 template iterator emplace(_Args&&... __args) { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); } # 481 "/usr/include/c++/10/bits/stl_multiset.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_t._M_emplace_hint_equal(__pos, std::forward<_Args>(__args)...); } # 501 "/usr/include/c++/10/bits/stl_multiset.h" 3 iterator insert(const value_type& __x) { return _M_t._M_insert_equal(__x); } iterator insert(value_type&& __x) { return _M_t._M_insert_equal(std::move(__x)); } # 531 "/usr/include/c++/10/bits/stl_multiset.h" 3 iterator insert(const_iterator __position, const value_type& __x) { return _M_t._M_insert_equal_(__position, __x); } iterator insert(const_iterator __position, value_type&& __x) { return _M_t._M_insert_equal_(__position, std::move(__x)); } # 549 "/usr/include/c++/10/bits/stl_multiset.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_t._M_insert_range_equal(__first, __last); } # 562 "/usr/include/c++/10/bits/stl_multiset.h" 3 void insert(initializer_list __l) { this->insert(__l.begin(), __l.end()); } node_type extract(const_iterator __pos) { ; return _M_t.extract(__pos); } node_type extract(const key_type& __x) { return _M_t.extract(__x); } iterator insert(node_type&& __nh) { return _M_t._M_reinsert_node_equal(std::move(__nh)); } iterator insert(const_iterator __hint, node_type&& __nh) { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); } template friend class std::_Rb_tree_merge_helper; template void merge(multiset<_Key, _Compare1, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); } template void merge(multiset<_Key, _Compare1, _Alloc>&& __source) { merge(__source); } template void merge(set<_Key, _Compare1, _Alloc>& __source) { using _Merge_helper = _Rb_tree_merge_helper; _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source)); } template void merge(set<_Key, _Compare1, _Alloc>&& __source) { merge(__source); } # 637 "/usr/include/c++/10/bits/stl_multiset.h" 3 __attribute ((__abi_tag__ ("cxx11"))) iterator erase(const_iterator __position) { return _M_t.erase(__position); } # 668 "/usr/include/c++/10/bits/stl_multiset.h" 3 size_type erase(const key_type& __x) { return _M_t.erase(__x); } # 689 "/usr/include/c++/10/bits/stl_multiset.h" 3 __attribute ((__abi_tag__ ("cxx11"))) iterator erase(const_iterator __first, const_iterator __last) { return _M_t.erase(__first, __last); } # 717 "/usr/include/c++/10/bits/stl_multiset.h" 3 void clear() noexcept { _M_t.clear(); } # 729 "/usr/include/c++/10/bits/stl_multiset.h" 3 size_type count(const key_type& __x) const { return _M_t.count(__x); } template auto count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x)) { return _M_t._M_count_tr(__x); } # 748 "/usr/include/c++/10/bits/stl_multiset.h" 3 bool contains(const key_type& __x) const { return _M_t.find(__x) != _M_t.end(); } template auto contains(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x), void(), true) { return _M_t._M_find_tr(__x) != _M_t.end(); } # 774 "/usr/include/c++/10/bits/stl_multiset.h" 3 iterator find(const key_type& __x) { return _M_t.find(__x); } const_iterator find(const key_type& __x) const { return _M_t.find(__x); } template auto find(const _Kt& __x) -> decltype(iterator{_M_t._M_find_tr(__x)}) { return iterator{_M_t._M_find_tr(__x)}; } template auto find(const _Kt& __x) const -> decltype(const_iterator{_M_t._M_find_tr(__x)}) { return const_iterator{_M_t._M_find_tr(__x)}; } # 809 "/usr/include/c++/10/bits/stl_multiset.h" 3 iterator lower_bound(const key_type& __x) { return _M_t.lower_bound(__x); } const_iterator lower_bound(const key_type& __x) const { return _M_t.lower_bound(__x); } template auto lower_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) { return iterator(_M_t._M_lower_bound_tr(__x)); } template auto lower_bound(const _Kt& __x) const -> decltype(iterator(_M_t._M_lower_bound_tr(__x))) { return iterator(_M_t._M_lower_bound_tr(__x)); } # 839 "/usr/include/c++/10/bits/stl_multiset.h" 3 iterator upper_bound(const key_type& __x) { return _M_t.upper_bound(__x); } const_iterator upper_bound(const key_type& __x) const { return _M_t.upper_bound(__x); } template auto upper_bound(const _Kt& __x) -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) { return iterator(_M_t._M_upper_bound_tr(__x)); } template auto upper_bound(const _Kt& __x) const -> decltype(iterator(_M_t._M_upper_bound_tr(__x))) { return iterator(_M_t._M_upper_bound_tr(__x)); } # 878 "/usr/include/c++/10/bits/stl_multiset.h" 3 std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } template auto equal_range(const _Kt& __x) -> decltype(pair(_M_t._M_equal_range_tr(__x))) { return pair(_M_t._M_equal_range_tr(__x)); } template auto equal_range(const _Kt& __x) const -> decltype(pair(_M_t._M_equal_range_tr(__x))) { return pair(_M_t._M_equal_range_tr(__x)); } template friend bool operator==(const multiset<_K1, _C1, _A1>&, const multiset<_K1, _C1, _A1>&); template friend __detail::__synth3way_t<_K1> operator<=>(const multiset<_K1, _C1, _A1>&, const multiset<_K1, _C1, _A1>&); }; template::value_type>, typename _Allocator = allocator::value_type>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> multiset(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator()) -> multiset::value_type, _Compare, _Allocator>; template, typename _Allocator = allocator<_Key>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> multiset(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator()) -> multiset<_Key, _Compare, _Allocator>; template, typename = _RequireAllocator<_Allocator>> multiset(_InputIterator, _InputIterator, _Allocator) -> multiset::value_type, less::value_type>, _Allocator>; template> multiset(initializer_list<_Key>, _Allocator) -> multiset<_Key, less<_Key>, _Allocator>; # 969 "/usr/include/c++/10/bits/stl_multiset.h" 3 template inline bool operator==(const multiset<_Key, _Compare, _Alloc>& __x, const multiset<_Key, _Compare, _Alloc>& __y) { return __x._M_t == __y._M_t; } # 990 "/usr/include/c++/10/bits/stl_multiset.h" 3 template inline __detail::__synth3way_t<_Key> operator<=>(const multiset<_Key, _Compare, _Alloc>& __x, const multiset<_Key, _Compare, _Alloc>& __y) { return __x._M_t <=> __y._M_t; } # 1043 "/usr/include/c++/10/bits/stl_multiset.h" 3 template inline void swap(multiset<_Key, _Compare, _Alloc>& __x, multiset<_Key, _Compare, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct _Rb_tree_merge_helper, _Cmp2> { private: friend class std::multiset<_Val, _Cmp1, _Alloc>; static auto& _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set) { return __set._M_t; } static auto& _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set) { return __set._M_t; } }; } # 63 "/usr/include/c++/10/set" 2 3 # 71 "/usr/include/c++/10/set" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template> using set = std::set<_Key, _Cmp, polymorphic_allocator<_Key>>; template> using multiset = std::multiset<_Key, _Cmp, polymorphic_allocator<_Key>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename set<_Key, _Compare, _Alloc>::size_type erase_if(set<_Key, _Compare, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } template inline typename multiset<_Key, _Compare, _Alloc>::size_type erase_if(multiset<_Key, _Compare, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } } # 62 "all-std.cxx" 2 # 1 "/usr/include/c++/10/span" 1 3 # 37 "/usr/include/c++/10/span" 3 # 38 "/usr/include/c++/10/span" 3 # 47 "/usr/include/c++/10/span" 3 namespace std __attribute__ ((__visibility__ ("default"))) { inline constexpr size_t dynamic_extent = static_cast(-1); template class span; namespace __detail { template struct __is_std_span : false_type { }; template struct __is_std_span> : true_type { }; template struct __is_std_array : false_type { }; template struct __is_std_array> : true_type { }; template class __extent_storage { public: constexpr __extent_storage(size_t) noexcept { } static constexpr size_t _M_extent() noexcept { return _Extent; } }; template<> class __extent_storage { 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 class span { template 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 requires (_Extent == dynamic_extent || _ArrayExtent == _Extent) using __is_compatible_array = __is_array_convertible<_Type, _Tp>; template 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; using reverse_iterator = std::reverse_iterator; static constexpr size_t extent = _Extent; constexpr span() noexcept requires ((_Extent + 1u) <= 1u) : _M_extent(0), _M_ptr(nullptr) { } template requires __is_compatible_ref>::value constexpr explicit(extent != dynamic_extent) span(_It __first, size_type __count) noexcept : _M_extent(__count), _M_ptr(std::to_address(__first)) { if constexpr (_Extent != dynamic_extent) { ; } } template _End> requires __is_compatible_ref>::value && (!is_convertible_v<_End, size_type>) constexpr explicit(extent != dynamic_extent) span(_It __first, _End __last) noexcept(noexcept(__last - __first)) : _M_extent(static_cast(__last - __first)), _M_ptr(std::to_address(__first)) { if constexpr (_Extent != dynamic_extent) { ; } } template requires (_Extent == dynamic_extent || _ArrayExtent == _Extent) constexpr span(type_identity_t (&__arr)[_ArrayExtent]) noexcept : span(static_cast(__arr), _ArrayExtent) { } template requires __is_compatible_array<_Tp, _ArrayExtent>::value constexpr span(array<_Tp, _ArrayExtent>& __arr) noexcept : span(static_cast(__arr.data()), _ArrayExtent) { } template requires __is_compatible_array::value constexpr span(const array<_Tp, _ArrayExtent>& __arr) noexcept : span(static_cast(__arr.data()), _ArrayExtent) { } template requires ranges::contiguous_range<_Range> && ranges::sized_range<_Range> && (ranges::borrowed_range<_Range> || is_const_v) && (!__detail::__is_std_span>::value) && (!__detail::__is_std_array>::value) && (!is_array_v>) && __is_compatible_ref>::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) { ; } } constexpr span(const span&) noexcept = default; template 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) { ; } } ~span() noexcept = default; constexpr span& operator=(const span&) noexcept = default; constexpr size_type size() const noexcept { return this->_M_extent._M_extent(); } 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; } constexpr reference front() const noexcept { ; return *this->_M_ptr; } constexpr reference back() const noexcept { ; return *(this->_M_ptr + (size() - 1)); } constexpr reference operator[](size_type __idx) const noexcept { ; return *(this->_M_ptr + __idx); } constexpr pointer data() const noexcept { return this->_M_ptr; } constexpr iterator begin() const noexcept { return iterator(this->_M_ptr); } constexpr iterator end() const noexcept { return iterator(this->_M_ptr + this->size()); } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(this->end()); } constexpr reverse_iterator rend() const noexcept { return reverse_iterator(this->begin()); } template constexpr span first() const noexcept { if constexpr (_Extent == dynamic_extent) ; else static_assert(_Count <= extent); using _Sp = span; return _Sp{ this->data(), _Count }; } constexpr span first(size_type __count) const noexcept { ; return { this->data(), __count }; } template constexpr span last() const noexcept { if constexpr (_Extent == dynamic_extent) ; else static_assert(_Count <= extent); using _Sp = span; return _Sp{ this->data() + (this->size() - _Count), _Count }; } constexpr span last(size_type __count) const noexcept { ; return { this->data() + (this->size() - __count), __count }; } template constexpr auto subspan() const noexcept -> span()> { if constexpr (_Extent == dynamic_extent) { ; } else static_assert(_Offset <= extent); using _Sp = span()>; if constexpr (_Count == dynamic_extent) return _Sp{ this->data() + _Offset, this->size() - _Offset }; else { if constexpr (_Extent == dynamic_extent) { ; ; } else { static_assert(_Count <= extent); static_assert(_Count <= (extent - _Offset)); } return _Sp{ this->data() + _Offset, _Count }; } } constexpr span subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept { ; if (__count == dynamic_extent) __count = this->size() - __offset; else { ; ; } return {this->data() + __offset, __count}; } private: [[no_unique_address]] __detail::__extent_storage _M_extent; pointer _M_ptr; }; template span(_Type(&)[_ArrayExtent]) -> span<_Type, _ArrayExtent>; template span(array<_Type, _ArrayExtent>&) -> span<_Type, _ArrayExtent>; template span(const array<_Type, _ArrayExtent>&) -> span; template span(_Iter, _End) -> span>>; template span(_Range &&) -> span>>; template inline span as_bytes(span<_Type, _Extent> __sp) noexcept { auto data = reinterpret_cast(__sp.data()); auto size = __sp.size_bytes(); constexpr auto extent = _Extent == dynamic_extent ? dynamic_extent : _Extent * sizeof(_Type); return span{data, size}; } template inline span as_writable_bytes(span<_Type, _Extent> __sp) noexcept { auto data = reinterpret_cast(__sp.data()); auto size = __sp.size_bytes(); constexpr auto extent = _Extent == dynamic_extent ? dynamic_extent : _Extent * sizeof(_Type); return span{data, size}; } namespace ranges { template inline constexpr bool enable_borrowed_range> = true; template inline constexpr bool enable_view> = _Extent == 0 || _Extent == dynamic_extent; } } # 63 "all-std.cxx" 2 # 1 "/usr/include/c++/10/stack" 1 3 # 58 "/usr/include/c++/10/stack" 3 # 59 "/usr/include/c++/10/stack" 3 # 1 "/usr/include/c++/10/bits/stl_stack.h" 1 3 # 65 "/usr/include/c++/10/bits/stl_stack.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 98 "/usr/include/c++/10/bits/stl_stack.h" 3 template > class stack { # 111 "/usr/include/c++/10/bits/stl_stack.h" 3 template friend bool operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&); template friend bool operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&); template friend compare_three_way_result_t<_Seq1> operator<=>(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&); template using _Uses = typename enable_if::value>::type; static_assert(is_same<_Tp, typename _Sequence::value_type>::value, "value_type must be the same as the underlying container"); public: typedef typename _Sequence::value_type value_type; typedef typename _Sequence::reference reference; typedef typename _Sequence::const_reference const_reference; typedef typename _Sequence::size_type size_type; typedef _Sequence container_type; protected: _Sequence c; public: # 160 "/usr/include/c++/10/bits/stl_stack.h" 3 template::value>::type> stack() : c() { } explicit stack(const _Sequence& __c) : c(__c) { } explicit stack(_Sequence&& __c) : c(std::move(__c)) { } template> explicit stack(const _Alloc& __a) : c(__a) { } template> stack(const _Sequence& __c, const _Alloc& __a) : c(__c, __a) { } template> stack(_Sequence&& __c, const _Alloc& __a) : c(std::move(__c), __a) { } template> stack(const stack& __q, const _Alloc& __a) : c(__q.c, __a) { } template> stack(stack&& __q, const _Alloc& __a) : c(std::move(__q.c), __a) { } [[__nodiscard__]] bool empty() const { return c.empty(); } size_type size() const { return c.size(); } reference top() { ; return c.back(); } const_reference top() const { ; return c.back(); } # 238 "/usr/include/c++/10/bits/stl_stack.h" 3 void push(const value_type& __x) { c.push_back(__x); } void push(value_type&& __x) { c.push_back(std::move(__x)); } template decltype(auto) emplace(_Args&&... __args) { return c.emplace_back(std::forward<_Args>(__args)...); } # 271 "/usr/include/c++/10/bits/stl_stack.h" 3 void pop() { ; c.pop_back(); } void swap(stack& __s) noexcept(__is_nothrow_swappable<_Sequence>::value) { using std::swap; swap(c, __s.c); } }; template> stack(_Container) -> stack; template, typename = _RequireAllocator<_Allocator>> stack(_Container, _Allocator) -> stack; # 317 "/usr/include/c++/10/bits/stl_stack.h" 3 template inline bool operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) { return __x.c == __y.c; } # 335 "/usr/include/c++/10/bits/stl_stack.h" 3 template inline bool operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) { return __x.c < __y.c; } template inline bool operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) { return !(__x == __y); } template inline bool operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) { return __y < __x; } template inline bool operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) { return !(__y < __x); } template inline bool operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) { return !(__x < __y); } template inline compare_three_way_result_t<_Seq> operator<=>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) { return __x.c <=> __y.c; } template inline typename enable_if<__is_swappable<_Seq>::value>::type swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template struct uses_allocator, _Alloc> : public uses_allocator<_Seq, _Alloc>::type { }; } # 62 "/usr/include/c++/10/stack" 2 3 # 64 "all-std.cxx" 2 # 1 "/usr/include/c++/10/unordered_set" 1 3 # 32 "/usr/include/c++/10/unordered_set" 3 # 33 "/usr/include/c++/10/unordered_set" 3 # 47 "/usr/include/c++/10/unordered_set" 3 # 1 "/usr/include/c++/10/bits/unordered_set.h" 1 3 # 33 "/usr/include/c++/10/bits/unordered_set.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template using __uset_traits = __detail::_Hashtable_traits<_Cache, true, true>; template, typename _Pred = std::equal_to<_Value>, typename _Alloc = std::allocator<_Value>, typename _Tr = __uset_traits<__cache_default<_Value, _Hash>::value>> using __uset_hashtable = _Hashtable<_Value, _Value, _Alloc, __detail::_Identity, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr>; template using __umset_traits = __detail::_Hashtable_traits<_Cache, true, false>; template, typename _Pred = std::equal_to<_Value>, typename _Alloc = std::allocator<_Value>, typename _Tr = __umset_traits<__cache_default<_Value, _Hash>::value>> using __umset_hashtable = _Hashtable<_Value, _Value, _Alloc, __detail::_Identity, _Pred, _Hash, __detail::_Mod_range_hashing, __detail::_Default_ranged_hash, __detail::_Prime_rehash_policy, _Tr>; template class unordered_multiset; # 93 "/usr/include/c++/10/bits/unordered_set.h" 3 template, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>> class unordered_set { typedef __uset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable; _Hashtable _M_h; public: typedef typename _Hashtable::key_type key_type; typedef typename _Hashtable::value_type value_type; typedef typename _Hashtable::hasher hasher; typedef typename _Hashtable::key_equal key_equal; typedef typename _Hashtable::allocator_type allocator_type; typedef typename _Hashtable::pointer pointer; typedef typename _Hashtable::const_pointer const_pointer; typedef typename _Hashtable::reference reference; typedef typename _Hashtable::const_reference const_reference; typedef typename _Hashtable::iterator iterator; typedef typename _Hashtable::const_iterator const_iterator; typedef typename _Hashtable::local_iterator local_iterator; typedef typename _Hashtable::const_local_iterator const_local_iterator; typedef typename _Hashtable::size_type size_type; typedef typename _Hashtable::difference_type difference_type; using node_type = typename _Hashtable::node_type; using insert_return_type = typename _Hashtable::insert_return_type; unordered_set() = default; # 144 "/usr/include/c++/10/bits/unordered_set.h" 3 explicit unordered_set(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__n, __hf, __eql, __a) { } # 165 "/usr/include/c++/10/bits/unordered_set.h" 3 template unordered_set(_InputIterator __first, _InputIterator __last, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__first, __last, __n, __hf, __eql, __a) { } unordered_set(const unordered_set&) = default; unordered_set(unordered_set&&) = default; explicit unordered_set(const allocator_type& __a) : _M_h(__a) { } unordered_set(const unordered_set& __uset, const allocator_type& __a) : _M_h(__uset._M_h, __a) { } unordered_set(unordered_set&& __uset, const allocator_type& __a) : _M_h(std::move(__uset._M_h), __a) { } # 220 "/usr/include/c++/10/bits/unordered_set.h" 3 unordered_set(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__l, __n, __hf, __eql, __a) { } unordered_set(size_type __n, const allocator_type& __a) : unordered_set(__n, hasher(), key_equal(), __a) { } unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__n, __hf, key_equal(), __a) { } template unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__first, __last, __n, __hf, key_equal(), __a) { } unordered_set(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_set(__l, __n, hasher(), key_equal(), __a) { } unordered_set(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__l, __n, __hf, key_equal(), __a) { } unordered_set& operator=(const unordered_set&) = default; unordered_set& operator=(unordered_set&&) = default; # 282 "/usr/include/c++/10/bits/unordered_set.h" 3 unordered_set& operator=(initializer_list __l) { _M_h = __l; return *this; } allocator_type get_allocator() const noexcept { return _M_h.get_allocator(); } [[__nodiscard__]] bool empty() const noexcept { return _M_h.empty(); } size_type size() const noexcept { return _M_h.size(); } size_type max_size() const noexcept { return _M_h.max_size(); } # 318 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator begin() noexcept { return _M_h.begin(); } const_iterator begin() const noexcept { return _M_h.begin(); } iterator end() noexcept { return _M_h.end(); } const_iterator end() const noexcept { return _M_h.end(); } const_iterator cbegin() const noexcept { return _M_h.begin(); } const_iterator cend() const noexcept { return _M_h.end(); } # 374 "/usr/include/c++/10/bits/unordered_set.h" 3 template std::pair emplace(_Args&&... __args) { return _M_h.emplace(std::forward<_Args>(__args)...); } # 400 "/usr/include/c++/10/bits/unordered_set.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } # 419 "/usr/include/c++/10/bits/unordered_set.h" 3 std::pair insert(const value_type& __x) { return _M_h.insert(__x); } std::pair insert(value_type&& __x) { return _M_h.insert(std::move(__x)); } # 448 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator insert(const_iterator __hint, const value_type& __x) { return _M_h.insert(__hint, __x); } iterator insert(const_iterator __hint, value_type&& __x) { return _M_h.insert(__hint, std::move(__x)); } # 466 "/usr/include/c++/10/bits/unordered_set.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_h.insert(__first, __last); } # 478 "/usr/include/c++/10/bits/unordered_set.h" 3 void insert(initializer_list __l) { _M_h.insert(__l); } node_type extract(const_iterator __pos) { ; return _M_h.extract(__pos); } node_type extract(const key_type& __key) { return _M_h.extract(__key); } insert_return_type insert(node_type&& __nh) { return _M_h._M_reinsert_node(std::move(__nh)); } iterator insert(const_iterator, node_type&& __nh) { return _M_h._M_reinsert_node(std::move(__nh)).position; } # 521 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator erase(const_iterator __position) { return _M_h.erase(__position); } iterator erase(iterator __position) { return _M_h.erase(__position); } # 543 "/usr/include/c++/10/bits/unordered_set.h" 3 size_type erase(const key_type& __x) { return _M_h.erase(__x); } # 561 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_h.erase(__first, __last); } void clear() noexcept { _M_h.clear(); } # 584 "/usr/include/c++/10/bits/unordered_set.h" 3 void swap(unordered_set& __x) noexcept( noexcept(_M_h.swap(__x._M_h)) ) { _M_h.swap(__x._M_h); } template friend class std::_Hash_merge_helper; template void merge(unordered_set<_Value, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_set<_Value, _H2, _P2, _Alloc>&& __source) { merge(__source); } template void merge(unordered_multiset<_Value, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_multiset<_Value, _H2, _P2, _Alloc>&& __source) { merge(__source); } hasher hash_function() const { return _M_h.hash_function(); } key_equal key_eq() const { return _M_h.key_eq(); } # 648 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator find(const key_type& __x) { return _M_h.find(__x); } const_iterator find(const key_type& __x) const { return _M_h.find(__x); } # 666 "/usr/include/c++/10/bits/unordered_set.h" 3 size_type count(const key_type& __x) const { return _M_h.count(__x); } bool contains(const key_type& __x) const { return _M_h.find(__x) != _M_h.end(); } # 690 "/usr/include/c++/10/bits/unordered_set.h" 3 std::pair equal_range(const key_type& __x) { return _M_h.equal_range(__x); } std::pair equal_range(const key_type& __x) const { return _M_h.equal_range(__x); } size_type bucket_count() const noexcept { return _M_h.bucket_count(); } size_type max_bucket_count() const noexcept { return _M_h.max_bucket_count(); } size_type bucket_size(size_type __n) const { return _M_h.bucket_size(__n); } size_type bucket(const key_type& __key) const { return _M_h.bucket(__key); } # 736 "/usr/include/c++/10/bits/unordered_set.h" 3 local_iterator begin(size_type __n) { return _M_h.begin(__n); } const_local_iterator begin(size_type __n) const { return _M_h.begin(__n); } const_local_iterator cbegin(size_type __n) const { return _M_h.cbegin(__n); } # 756 "/usr/include/c++/10/bits/unordered_set.h" 3 local_iterator end(size_type __n) { return _M_h.end(__n); } const_local_iterator end(size_type __n) const { return _M_h.end(__n); } const_local_iterator cend(size_type __n) const { return _M_h.cend(__n); } float load_factor() const noexcept { return _M_h.load_factor(); } float max_load_factor() const noexcept { return _M_h.max_load_factor(); } void max_load_factor(float __z) { _M_h.max_load_factor(__z); } # 797 "/usr/include/c++/10/bits/unordered_set.h" 3 void rehash(size_type __n) { _M_h.rehash(__n); } # 808 "/usr/include/c++/10/bits/unordered_set.h" 3 void reserve(size_type __n) { _M_h.reserve(__n); } template friend bool operator==(const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&, const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&); }; template::value_type>, typename _Pred = equal_to::value_type>, typename _Allocator = allocator::value_type>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_set(_InputIterator, _InputIterator, unordered_set::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_set::value_type, _Hash, _Pred, _Allocator>; template, typename _Pred = equal_to<_Tp>, typename _Allocator = allocator<_Tp>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_set(initializer_list<_Tp>, unordered_set::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_set<_Tp, _Hash, _Pred, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_set(_InputIterator, _InputIterator, unordered_set::size_type, _Allocator) -> unordered_set::value_type, hash< typename iterator_traits<_InputIterator>::value_type>, equal_to< typename iterator_traits<_InputIterator>::value_type>, _Allocator>; template, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireAllocator<_Allocator>> unordered_set(_InputIterator, _InputIterator, unordered_set::size_type, _Hash, _Allocator) -> unordered_set::value_type, _Hash, equal_to< typename iterator_traits<_InputIterator>::value_type>, _Allocator>; template> unordered_set(initializer_list<_Tp>, unordered_set::size_type, _Allocator) -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_set(initializer_list<_Tp>, unordered_set::size_type, _Hash, _Allocator) -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>; # 908 "/usr/include/c++/10/bits/unordered_set.h" 3 template, typename _Pred = equal_to<_Value>, typename _Alloc = allocator<_Value>> class unordered_multiset { typedef __umset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable; _Hashtable _M_h; public: typedef typename _Hashtable::key_type key_type; typedef typename _Hashtable::value_type value_type; typedef typename _Hashtable::hasher hasher; typedef typename _Hashtable::key_equal key_equal; typedef typename _Hashtable::allocator_type allocator_type; typedef typename _Hashtable::pointer pointer; typedef typename _Hashtable::const_pointer const_pointer; typedef typename _Hashtable::reference reference; typedef typename _Hashtable::const_reference const_reference; typedef typename _Hashtable::iterator iterator; typedef typename _Hashtable::const_iterator const_iterator; typedef typename _Hashtable::local_iterator local_iterator; typedef typename _Hashtable::const_local_iterator const_local_iterator; typedef typename _Hashtable::size_type size_type; typedef typename _Hashtable::difference_type difference_type; using node_type = typename _Hashtable::node_type; unordered_multiset() = default; # 958 "/usr/include/c++/10/bits/unordered_set.h" 3 explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__n, __hf, __eql, __a) { } # 979 "/usr/include/c++/10/bits/unordered_set.h" 3 template unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__first, __last, __n, __hf, __eql, __a) { } unordered_multiset(const unordered_multiset&) = default; unordered_multiset(unordered_multiset&&) = default; # 1005 "/usr/include/c++/10/bits/unordered_set.h" 3 unordered_multiset(initializer_list __l, size_type __n = 0, const hasher& __hf = hasher(), const key_equal& __eql = key_equal(), const allocator_type& __a = allocator_type()) : _M_h(__l, __n, __hf, __eql, __a) { } unordered_multiset& operator=(const unordered_multiset&) = default; unordered_multiset& operator=(unordered_multiset&&) = default; explicit unordered_multiset(const allocator_type& __a) : _M_h(__a) { } unordered_multiset(const unordered_multiset& __umset, const allocator_type& __a) : _M_h(__umset._M_h, __a) { } unordered_multiset(unordered_multiset&& __umset, const allocator_type& __a) : _M_h(std::move(__umset._M_h), __a) { } unordered_multiset(size_type __n, const allocator_type& __a) : unordered_multiset(__n, hasher(), key_equal(), __a) { } unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__n, __hf, key_equal(), __a) { } template unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) { } template unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) { } unordered_multiset(initializer_list __l, size_type __n, const allocator_type& __a) : unordered_multiset(__l, __n, hasher(), key_equal(), __a) { } unordered_multiset(initializer_list __l, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__l, __n, __hf, key_equal(), __a) { } # 1096 "/usr/include/c++/10/bits/unordered_set.h" 3 unordered_multiset& operator=(initializer_list __l) { _M_h = __l; return *this; } allocator_type get_allocator() const noexcept { return _M_h.get_allocator(); } [[__nodiscard__]] bool empty() const noexcept { return _M_h.empty(); } size_type size() const noexcept { return _M_h.size(); } size_type max_size() const noexcept { return _M_h.max_size(); } # 1132 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator begin() noexcept { return _M_h.begin(); } const_iterator begin() const noexcept { return _M_h.begin(); } iterator end() noexcept { return _M_h.end(); } const_iterator end() const noexcept { return _M_h.end(); } const_iterator cbegin() const noexcept { return _M_h.begin(); } const_iterator cend() const noexcept { return _M_h.end(); } # 1180 "/usr/include/c++/10/bits/unordered_set.h" 3 template iterator emplace(_Args&&... __args) { return _M_h.emplace(std::forward<_Args>(__args)...); } # 1202 "/usr/include/c++/10/bits/unordered_set.h" 3 template iterator emplace_hint(const_iterator __pos, _Args&&... __args) { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } # 1215 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator insert(const value_type& __x) { return _M_h.insert(__x); } iterator insert(value_type&& __x) { return _M_h.insert(std::move(__x)); } # 1241 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator insert(const_iterator __hint, const value_type& __x) { return _M_h.insert(__hint, __x); } iterator insert(const_iterator __hint, value_type&& __x) { return _M_h.insert(__hint, std::move(__x)); } # 1258 "/usr/include/c++/10/bits/unordered_set.h" 3 template void insert(_InputIterator __first, _InputIterator __last) { _M_h.insert(__first, __last); } # 1270 "/usr/include/c++/10/bits/unordered_set.h" 3 void insert(initializer_list __l) { _M_h.insert(__l); } node_type extract(const_iterator __pos) { ; return _M_h.extract(__pos); } node_type extract(const key_type& __key) { return _M_h.extract(__key); } iterator insert(node_type&& __nh) { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); } iterator insert(const_iterator __hint, node_type&& __nh) { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); } # 1314 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator erase(const_iterator __position) { return _M_h.erase(__position); } iterator erase(iterator __position) { return _M_h.erase(__position); } # 1337 "/usr/include/c++/10/bits/unordered_set.h" 3 size_type erase(const key_type& __x) { return _M_h.erase(__x); } # 1357 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator erase(const_iterator __first, const_iterator __last) { return _M_h.erase(__first, __last); } # 1368 "/usr/include/c++/10/bits/unordered_set.h" 3 void clear() noexcept { _M_h.clear(); } # 1381 "/usr/include/c++/10/bits/unordered_set.h" 3 void swap(unordered_multiset& __x) noexcept( noexcept(_M_h.swap(__x._M_h)) ) { _M_h.swap(__x._M_h); } template friend class std::_Hash_merge_helper; template void merge(unordered_multiset<_Value, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_multiset<_Value, _H2, _P2, _Alloc>&& __source) { merge(__source); } template void merge(unordered_set<_Value, _H2, _P2, _Alloc>& __source) { using _Merge_helper = _Hash_merge_helper; _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); } template void merge(unordered_set<_Value, _H2, _P2, _Alloc>&& __source) { merge(__source); } hasher hash_function() const { return _M_h.hash_function(); } key_equal key_eq() const { return _M_h.key_eq(); } # 1447 "/usr/include/c++/10/bits/unordered_set.h" 3 iterator find(const key_type& __x) { return _M_h.find(__x); } const_iterator find(const key_type& __x) const { return _M_h.find(__x); } size_type count(const key_type& __x) const { return _M_h.count(__x); } bool contains(const key_type& __x) const { return _M_h.find(__x) != _M_h.end(); } # 1483 "/usr/include/c++/10/bits/unordered_set.h" 3 std::pair equal_range(const key_type& __x) { return _M_h.equal_range(__x); } std::pair equal_range(const key_type& __x) const { return _M_h.equal_range(__x); } size_type bucket_count() const noexcept { return _M_h.bucket_count(); } size_type max_bucket_count() const noexcept { return _M_h.max_bucket_count(); } size_type bucket_size(size_type __n) const { return _M_h.bucket_size(__n); } size_type bucket(const key_type& __key) const { return _M_h.bucket(__key); } # 1529 "/usr/include/c++/10/bits/unordered_set.h" 3 local_iterator begin(size_type __n) { return _M_h.begin(__n); } const_local_iterator begin(size_type __n) const { return _M_h.begin(__n); } const_local_iterator cbegin(size_type __n) const { return _M_h.cbegin(__n); } # 1549 "/usr/include/c++/10/bits/unordered_set.h" 3 local_iterator end(size_type __n) { return _M_h.end(__n); } const_local_iterator end(size_type __n) const { return _M_h.end(__n); } const_local_iterator cend(size_type __n) const { return _M_h.cend(__n); } float load_factor() const noexcept { return _M_h.load_factor(); } float max_load_factor() const noexcept { return _M_h.max_load_factor(); } void max_load_factor(float __z) { _M_h.max_load_factor(__z); } # 1590 "/usr/include/c++/10/bits/unordered_set.h" 3 void rehash(size_type __n) { _M_h.rehash(__n); } # 1601 "/usr/include/c++/10/bits/unordered_set.h" 3 void reserve(size_type __n) { _M_h.reserve(__n); } template friend bool operator==(const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&, const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&); }; template::value_type>, typename _Pred = equal_to::value_type>, typename _Allocator = allocator::value_type>, typename = _RequireInputIter<_InputIterator>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_multiset(_InputIterator, _InputIterator, unordered_multiset::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_multiset::value_type, _Hash, _Pred, _Allocator>; template, typename _Pred = equal_to<_Tp>, typename _Allocator = allocator<_Tp>, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireNotAllocator<_Pred>, typename = _RequireAllocator<_Allocator>> unordered_multiset(initializer_list<_Tp>, unordered_multiset::size_type = {}, _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multiset(_InputIterator, _InputIterator, unordered_multiset::size_type, _Allocator) -> unordered_multiset::value_type, hash::value_type>, equal_to::value_type>, _Allocator>; template, typename = _RequireNotAllocatorOrIntegral<_Hash>, typename = _RequireAllocator<_Allocator>> unordered_multiset(_InputIterator, _InputIterator, unordered_multiset::size_type, _Hash, _Allocator) -> unordered_multiset::value_type, _Hash, equal_to< typename iterator_traits<_InputIterator>::value_type>, _Allocator>; template> unordered_multiset(initializer_list<_Tp>, unordered_multiset::size_type, _Allocator) -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>; template, typename = _RequireAllocator<_Allocator>> unordered_multiset(initializer_list<_Tp>, unordered_multiset::size_type, _Hash, _Allocator) -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>; template inline void swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline void swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } template inline bool operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) { return __x._M_h._M_equal(__y._M_h); } # 1715 "/usr/include/c++/10/bits/unordered_set.h" 3 template inline bool operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) { return __x._M_h._M_equal(__y._M_h); } # 1729 "/usr/include/c++/10/bits/unordered_set.h" 3 template struct _Hash_merge_helper< std::unordered_set<_Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2> { private: template using unordered_set = std::unordered_set<_Tp...>; template using unordered_multiset = std::unordered_multiset<_Tp...>; friend unordered_set<_Val, _Hash1, _Eq1, _Alloc>; static auto& _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set) { return __set._M_h; } static auto& _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set) { return __set._M_h; } }; template struct _Hash_merge_helper< std::unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2> { private: template using unordered_set = std::unordered_set<_Tp...>; template using unordered_multiset = std::unordered_multiset<_Tp...>; friend unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>; static auto& _S_get_table(unordered_set<_Val, _Hash2, _Eq2, _Alloc>& __set) { return __set._M_h; } static auto& _S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set) { return __set._M_h; } }; } # 48 "/usr/include/c++/10/unordered_set" 2 3 # 56 "/usr/include/c++/10/unordered_set" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template, typename _Pred = std::equal_to<_Key>> using unordered_set = std::unordered_set<_Key, _Hash, _Pred, polymorphic_allocator<_Key>>; template, typename _Pred = std::equal_to<_Key>> using unordered_multiset = std::unordered_multiset<_Key, _Hash, _Pred, polymorphic_allocator<_Key>>; } } namespace std __attribute__ ((__visibility__ ("default"))) { template inline typename unordered_set<_Key, _Hash, _CPred, _Alloc>::size_type erase_if(unordered_set<_Key, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } template inline typename unordered_multiset<_Key, _Hash, _CPred, _Alloc>::size_type erase_if(unordered_multiset<_Key, _Hash, _CPred, _Alloc>& __cont, _Predicate __pred) { return __detail::__erase_nodes_if(__cont, __pred); } } # 66 "all-std.cxx" 2 # 1 "/usr/include/c++/10/algorithm" 1 3 # 58 "/usr/include/c++/10/algorithm" 3 # 59 "/usr/include/c++/10/algorithm" 3 # 1 "/usr/include/c++/10/bits/ranges_algo.h" 1 3 # 39 "/usr/include/c++/10/bits/ranges_algo.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace ranges { namespace __detail { template constexpr auto __make_comp_proj(_Comp& __comp, _Proj& __proj) { return [&] (auto&& __lhs, auto&& __rhs) -> bool { using _TL = decltype(__lhs); using _TR = decltype(__rhs); return std::__invoke(__comp, std::__invoke(__proj, std::forward<_TL>(__lhs)), std::__invoke(__proj, std::forward<_TR>(__rhs))); }; } template constexpr auto __make_pred_proj(_Pred& __pred, _Proj& __proj) { return [&] (_Tp&& __arg) -> bool { return std::__invoke(__pred, std::__invoke(__proj, std::forward<_Tp>(__arg))); }; } } struct __all_of_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr bool operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (!(bool)std::__invoke(__pred, std::__invoke(__proj, *__first))) return false; return true; } template, _Proj>> _Pred> constexpr bool operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__pred), std::move(__proj)); } }; inline constexpr __all_of_fn all_of{}; struct __any_of_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr bool operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (std::__invoke(__pred, std::__invoke(__proj, *__first))) return true; return false; } template, _Proj>> _Pred> constexpr bool operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__pred), std::move(__proj)); } }; inline constexpr __any_of_fn any_of{}; struct __none_of_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr bool operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (std::__invoke(__pred, std::__invoke(__proj, *__first))) return false; return true; } template, _Proj>> _Pred> constexpr bool operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__pred), std::move(__proj)); } }; inline constexpr __none_of_fn none_of{}; template struct in_fun_result { [[no_unique_address]] _Iter in; [[no_unique_address]] _Fp fun; template requires convertible_to && convertible_to constexpr operator in_fun_result<_Iter2, _F2p>() const & { return {in, fun}; } template requires convertible_to<_Iter, _Iter2> && convertible_to<_Fp, _F2p> constexpr operator in_fun_result<_Iter2, _F2p>() && { return {std::move(in), std::move(fun)}; } }; template using for_each_result = in_fun_result<_Iter, _Fp>; struct __for_each_fn { template _Sent, typename _Proj = identity, indirectly_unary_invocable> _Fun> constexpr for_each_result<_Iter, _Fun> operator()(_Iter __first, _Sent __last, _Fun __f, _Proj __proj = {}) const { for (; __first != __last; ++__first) std::__invoke(__f, std::__invoke(__proj, *__first)); return { std::move(__first), std::move(__f) }; } template, _Proj>> _Fun> constexpr for_each_result, _Fun> operator()(_Range&& __r, _Fun __f, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__f), std::move(__proj)); } }; inline constexpr __for_each_fn for_each{}; template using for_each_n_result = in_fun_result<_Iter, _Fp>; struct __for_each_n_fn { template> _Fun> constexpr for_each_n_result<_Iter, _Fun> operator()(_Iter __first, iter_difference_t<_Iter> __n, _Fun __f, _Proj __proj = {}) const { if constexpr (random_access_iterator<_Iter>) { if (__n <= 0) return {std::move(__first), std::move(__f)}; auto __last = __first + __n; return ranges::for_each(std::move(__first), std::move(__last), std::move(__f), std::move(__proj)); } else { while (__n-- > 0) { std::__invoke(__f, std::__invoke(__proj, *__first)); ++__first; } return {std::move(__first), std::move(__f)}; } } }; inline constexpr __for_each_n_fn for_each_n{}; struct __find_fn { template _Sent, typename _Tp, typename _Proj = identity> requires indirect_binary_predicate, 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 requires indirect_binary_predicate, _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 _Sent, typename _Proj = identity, indirect_unary_predicate> _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, _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 _Sent, typename _Proj = identity, indirect_unary_predicate> _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, _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{}; struct __find_first_of_fn { template _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 _Iter1 operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { for (; __first1 != __last1; ++__first1) for (auto __iter = __first2; __iter != __last2; ++__iter) if (std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__iter))) return __first1; return __first1; } template requires indirectly_comparable, iterator_t<_Range2>, _Pred, _Proj1, _Proj2> constexpr borrowed_iterator_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 __find_first_of_fn find_first_of{}; struct __count_fn { template _Sent, typename _Tp, typename _Proj = identity> requires indirect_binary_predicate, const _Tp*> constexpr iter_difference_t<_Iter> operator()(_Iter __first, _Sent __last, const _Tp& __value, _Proj __proj = {}) const { iter_difference_t<_Iter> __n = 0; for (; __first != __last; ++__first) if (std::__invoke(__proj, *__first) == __value) ++__n; return __n; } template requires indirect_binary_predicate, _Proj>, const _Tp*> constexpr range_difference_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 __count_fn count{}; struct __count_if_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr iter_difference_t<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { iter_difference_t<_Iter> __n = 0; for (; __first != __last; ++__first) if (std::__invoke(__pred, std::__invoke(__proj, *__first))) ++__n; return __n; } template, _Proj>> _Pred> constexpr range_difference_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 __count_if_fn count_if{}; template struct in_in_result { [[no_unique_address]] _Iter1 in1; [[no_unique_address]] _Iter2 in2; template requires convertible_to && convertible_to constexpr operator in_in_result<_IIter1, _IIter2>() const & { return {in1, in2}; } template requires convertible_to<_Iter1, _IIter1> && convertible_to<_Iter2, _IIter2> constexpr operator in_in_result<_IIter1, _IIter2>() && { return {std::move(in1), std::move(in2)}; } }; template using mismatch_result = in_in_result<_Iter1, _Iter2>; struct __mismatch_fn { template _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 requires indirectly_comparable, iterator_t<_Range2>, _Pred, _Proj1, _Proj2> constexpr mismatch_result, 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 _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 requires indirectly_comparable, 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 __search_n_fn { template _Sent, typename _Tp, typename _Pred = ranges::equal_to, typename _Proj = identity> requires indirectly_comparable<_Iter, const _Tp*, _Pred, _Proj> constexpr subrange<_Iter> operator()(_Iter __first, _Sent __last, iter_difference_t<_Iter> __count, const _Tp& __value, _Pred __pred = {}, _Proj __proj = {}) const { if (__count <= 0) return {__first, __first}; auto __value_comp = [&] (_Rp&& __arg) { return std::__invoke(__pred, std::forward<_Rp>(__arg), __value); }; if (__count == 1) { __first = ranges::find_if(std::move(__first), __last, std::move(__value_comp), std::move(__proj)); if (__first == __last) return {__first, __first}; else { auto __end = __first; return {__first, ++__end}; } } if constexpr (sized_sentinel_for<_Sent, _Iter> && random_access_iterator<_Iter>) { auto __tail_size = __last - __first; auto __remainder = __count; while (__remainder <= __tail_size) { __first += __remainder; __tail_size -= __remainder; auto __backtrack = __first; while (__value_comp(std::__invoke(__proj, *--__backtrack))) { if (--__remainder == 0) return {__first - __count, __first}; } __remainder = __count + 1 - (__first - __backtrack); } auto __i = __first + __tail_size; return {__i, __i}; } else { __first = ranges::find_if(__first, __last, __value_comp, __proj); while (__first != __last) { auto __n = __count; auto __i = __first; ++__i; while (__i != __last && __n != 1 && __value_comp(std::__invoke(__proj, *__i))) { ++__i; --__n; } if (__n == 1) return {__first, __i}; if (__i == __last) return {__i, __i}; __first = ranges::find_if(++__i, __last, __value_comp, __proj); } return {__first, __first}; } } template requires indirectly_comparable, const _Tp*, _Pred, _Proj> constexpr borrowed_subrange_t<_Range> operator()(_Range&& __r, range_difference_t<_Range> __count, const _Tp& __value, _Pred __pred = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__count), __value, std::move(__pred), std::move(__proj)); } }; inline constexpr __search_n_fn search_n{}; struct __find_end_fn { template _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 constexpr (bidirectional_iterator<_Iter1> && bidirectional_iterator<_Iter2>) { auto __i1 = ranges::next(__first1, __last1); auto __i2 = ranges::next(__first2, __last2); auto __rresult = ranges::search(reverse_iterator<_Iter1>{__i1}, reverse_iterator<_Iter1>{__first1}, reverse_iterator<_Iter2>{__i2}, reverse_iterator<_Iter2>{__first2}, std::move(__pred), std::move(__proj1), std::move(__proj2)); auto __result_first = ranges::end(__rresult).base(); auto __result_last = ranges::begin(__rresult).base(); if (__result_last == __first1) return {__i1, __i1}; else return {__result_first, __result_last}; } else { auto __i = ranges::next(__first1, __last1); if (__first2 == __last2) return {__i, __i}; auto __result_begin = __i; auto __result_end = __i; for (;;) { auto __new_range = ranges::search(__first1, __last1, __first2, __last2, __pred, __proj1, __proj2); auto __new_result_begin = ranges::begin(__new_range); auto __new_result_end = ranges::end(__new_range); if (__new_result_begin == __last1) return {__result_begin, __result_end}; else { __result_begin = __new_result_begin; __result_end = __new_result_end; __first1 = __result_begin; ++__first1; } } } } template requires indirectly_comparable, 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 __find_end_fn find_end{}; struct __adjacent_find_fn { template _Sent, typename _Proj = identity, indirect_binary_predicate, 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, _Proj>, projected, _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{}; struct __is_permutation_fn { template _Sent1, forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2, typename _Proj1 = identity, typename _Proj2 = identity, indirect_equivalence_relation, projected<_Iter2, _Proj2>> _Pred = ranges::equal_to> constexpr bool operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { constexpr bool __sized_iters = (sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent2, _Iter2>); if constexpr (__sized_iters) { auto __d1 = ranges::distance(__first1, __last1); auto __d2 = ranges::distance(__first2, __last2); if (__d1 != __d2) return false; } for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) if (!(bool)std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) break; if constexpr (__sized_iters) { if (__first1 == __last1) return true; } else { auto __d1 = ranges::distance(__first1, __last1); auto __d2 = ranges::distance(__first2, __last2); if (__d1 == 0 && __d2 == 0) return true; if (__d1 != __d2) return false; } for (auto __scan = __first1; __scan != __last1; ++__scan) { auto __proj_scan = std::__invoke(__proj1, *__scan); auto __comp_scan = [&] (_Tp&& __arg) { return std::__invoke(__pred, __proj_scan, std::forward<_Tp>(__arg)); }; if (__scan != ranges::find_if(__first1, __scan, __comp_scan, __proj1)) continue; auto __matches = ranges::count_if(__first2, __last2, __comp_scan, __proj2); if (__matches == 0 || ranges::count_if(__scan, __last1, __comp_scan, __proj1) != __matches) return false; } return true; } template, _Proj1>, projected, _Proj2>> _Pred = ranges::equal_to> 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 __is_permutation_fn is_permutation{}; template using copy_if_result = in_out_result<_Iter, _Out>; struct __copy_if_fn { template _Sent, weakly_incrementable _Out, typename _Proj = identity, indirect_unary_predicate> _Pred> requires indirectly_copyable<_Iter, _Out> constexpr copy_if_result<_Iter, _Out> operator()(_Iter __first, _Sent __last, _Out __result, _Pred __pred, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (std::__invoke(__pred, std::__invoke(__proj, *__first))) { *__result = *__first; ++__result; } return {std::move(__first), std::move(__result)}; } template, _Proj>> _Pred> requires indirectly_copyable, _Out> constexpr copy_if_result, _Out> operator()(_Range&& __r, _Out __result, _Pred __pred, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result), std::move(__pred), std::move(__proj)); } }; inline constexpr __copy_if_fn copy_if{}; template using swap_ranges_result = in_in_result<_Iter1, _Iter2>; struct __swap_ranges_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2> requires indirectly_swappable<_Iter1, _Iter2> constexpr swap_ranges_result<_Iter1, _Iter2> operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2) const { for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2) ranges::iter_swap(__first1, __first2); return {std::move(__first1), std::move(__first2)}; } template requires indirectly_swappable, iterator_t<_Range2>> constexpr swap_ranges_result, borrowed_iterator_t<_Range2>> operator()(_Range1&& __r1, _Range2&& __r2) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2)); } }; inline constexpr __swap_ranges_fn swap_ranges{}; template using unary_transform_result = in_out_result<_Iter, _Out>; template struct in_in_out_result { [[no_unique_address]] _Iter1 in1; [[no_unique_address]] _Iter2 in2; [[no_unique_address]] _Out out; template requires convertible_to && convertible_to && convertible_to constexpr operator in_in_out_result<_IIter1, _IIter2, _OOut>() const & { return {in1, in2, out}; } template requires convertible_to<_Iter1, _IIter1> && convertible_to<_Iter2, _IIter2> && convertible_to<_Out, _OOut> constexpr operator in_in_out_result<_IIter1, _IIter2, _OOut>() && { return {std::move(in1), std::move(in2), std::move(out)}; } }; template using binary_transform_result = in_in_out_result<_Iter1, _Iter2, _Out>; struct __transform_fn { template _Sent, weakly_incrementable _Out, copy_constructible _Fp, typename _Proj = identity> requires indirectly_writable<_Out, indirect_result_t<_Fp&, projected<_Iter, _Proj>>> constexpr unary_transform_result<_Iter, _Out> operator()(_Iter __first1, _Sent __last1, _Out __result, _Fp __op, _Proj __proj = {}) const { for (; __first1 != __last1; ++__first1, (void)++__result) *__result = std::__invoke(__op, std::__invoke(__proj, *__first1)); return {std::move(__first1), std::move(__result)}; } template requires indirectly_writable<_Out, indirect_result_t<_Fp&, projected, _Proj>>> constexpr unary_transform_result, _Out> operator()(_Range&& __r, _Out __result, _Fp __op, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result), std::move(__op), std::move(__proj)); } template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, weakly_incrementable _Out, copy_constructible _Fp, typename _Proj1 = identity, typename _Proj2 = identity> requires indirectly_writable<_Out, indirect_result_t<_Fp&, projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>>> constexpr binary_transform_result<_Iter1, _Iter2, _Out> operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Out __result, _Fp __binary_op, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2, ++__result) *__result = std::__invoke(__binary_op, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)); return {std::move(__first1), std::move(__first2), std::move(__result)}; } template requires indirectly_writable<_Out, indirect_result_t<_Fp&, projected, _Proj1>, projected, _Proj2>>> constexpr binary_transform_result, borrowed_iterator_t<_Range2>, _Out> operator()(_Range1&& __r1, _Range2&& __r2, _Out __result, _Fp __binary_op, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__result), std::move(__binary_op), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __transform_fn transform{}; struct __replace_fn { template _Sent, typename _Tp1, typename _Tp2, typename _Proj = identity> requires indirectly_writable<_Iter, const _Tp2&> && indirect_binary_predicate, const _Tp1*> constexpr _Iter operator()(_Iter __first, _Sent __last, const _Tp1& __old_value, const _Tp2& __new_value, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (std::__invoke(__proj, *__first) == __old_value) *__first = __new_value; return __first; } template requires indirectly_writable, const _Tp2&> && indirect_binary_predicate, _Proj>, const _Tp1*> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, const _Tp1& __old_value, const _Tp2& __new_value, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), __old_value, __new_value, std::move(__proj)); } }; inline constexpr __replace_fn replace{}; struct __replace_if_fn { template _Sent, typename _Tp, typename _Proj = identity, indirect_unary_predicate> _Pred> requires indirectly_writable<_Iter, const _Tp&> constexpr _Iter operator()(_Iter __first, _Sent __last, _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (std::__invoke(__pred, std::__invoke(__proj, *__first))) *__first = __new_value; return std::move(__first); } template, _Proj>> _Pred> requires indirectly_writable, const _Tp&> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__pred), __new_value, std::move(__proj)); } }; inline constexpr __replace_if_fn replace_if{}; template using replace_copy_result = in_out_result<_Iter, _Out>; struct __replace_copy_fn { template _Sent, typename _Tp1, typename _Tp2, output_iterator _Out, typename _Proj = identity> requires indirectly_copyable<_Iter, _Out> && indirect_binary_predicate, const _Tp1*> constexpr replace_copy_result<_Iter, _Out> operator()(_Iter __first, _Sent __last, _Out __result, const _Tp1& __old_value, const _Tp2& __new_value, _Proj __proj = {}) const { for (; __first != __last; ++__first, (void)++__result) if (std::__invoke(__proj, *__first) == __old_value) *__result = __new_value; else *__result = *__first; return {std::move(__first), std::move(__result)}; } template _Out, typename _Proj = identity> requires indirectly_copyable, _Out> && indirect_binary_predicate, _Proj>, const _Tp1*> constexpr replace_copy_result, _Out> operator()(_Range&& __r, _Out __result, const _Tp1& __old_value, const _Tp2& __new_value, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result), __old_value, __new_value, std::move(__proj)); } }; inline constexpr __replace_copy_fn replace_copy{}; template using replace_copy_if_result = in_out_result<_Iter, _Out>; struct __replace_copy_if_fn { template _Sent, typename _Tp, output_iterator _Out, typename _Proj = identity, indirect_unary_predicate> _Pred> requires indirectly_copyable<_Iter, _Out> constexpr replace_copy_if_result<_Iter, _Out> operator()(_Iter __first, _Sent __last, _Out __result, _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const { for (; __first != __last; ++__first, (void)++__result) if (std::__invoke(__pred, std::__invoke(__proj, *__first))) *__result = __new_value; else *__result = *__first; return {std::move(__first), std::move(__result)}; } template _Out, typename _Proj = identity, indirect_unary_predicate, _Proj>> _Pred> requires indirectly_copyable, _Out> constexpr replace_copy_if_result, _Out> operator()(_Range&& __r, _Out __result, _Pred __pred, const _Tp& __new_value, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result), std::move(__pred), __new_value, std::move(__proj)); } }; inline constexpr __replace_copy_if_fn replace_copy_if{}; struct __generate_n_fn { template requires invocable<_Fp&> && indirectly_writable<_Out, invoke_result_t<_Fp&>> constexpr _Out operator()(_Out __first, iter_difference_t<_Out> __n, _Fp __gen) const { for (; __n > 0; --__n, (void)++__first) *__first = std::__invoke(__gen); return __first; } }; inline constexpr __generate_n_fn generate_n{}; struct __generate_fn { template _Sent, copy_constructible _Fp> requires invocable<_Fp&> && indirectly_writable<_Out, invoke_result_t<_Fp&>> constexpr _Out operator()(_Out __first, _Sent __last, _Fp __gen) const { for (; __first != __last; ++__first) *__first = std::__invoke(__gen); return __first; } template requires invocable<_Fp&> && output_range<_Range, invoke_result_t<_Fp&>> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Fp __gen) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__gen)); } }; inline constexpr __generate_fn generate{}; struct __remove_if_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr subrange<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { __first = ranges::find_if(__first, __last, __pred, __proj); if (__first == __last) return {__first, __first}; auto __result = __first; ++__first; for (; __first != __last; ++__first) if (!std::__invoke(__pred, std::__invoke(__proj, *__first))) { *__result = std::move(*__first); ++__result; } return {__result, __first}; } template, _Proj>> _Pred> requires permutable> constexpr borrowed_subrange_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 __remove_if_fn remove_if{}; struct __remove_fn { template _Sent, typename _Tp, typename _Proj = identity> requires indirect_binary_predicate, const _Tp*> constexpr subrange<_Iter> operator()(_Iter __first, _Sent __last, const _Tp& __value, _Proj __proj = {}) const { auto __pred = [&] (auto&& __arg) { return std::forward(__arg) == __value; }; return ranges::remove_if(__first, __last, std::move(__pred), std::move(__proj)); } template requires permutable> && indirect_binary_predicate, _Proj>, const _Tp*> constexpr borrowed_subrange_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 __remove_fn remove{}; template using remove_copy_if_result = in_out_result<_Iter, _Out>; struct __remove_copy_if_fn { template _Sent, weakly_incrementable _Out, typename _Proj = identity, indirect_unary_predicate> _Pred> requires indirectly_copyable<_Iter, _Out> constexpr remove_copy_if_result<_Iter, _Out> operator()(_Iter __first, _Sent __last, _Out __result, _Pred __pred, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (!std::__invoke(__pred, std::__invoke(__proj, *__first))) { *__result = *__first; ++__result; } return {std::move(__first), std::move(__result)}; } template, _Proj>> _Pred> requires indirectly_copyable, _Out> constexpr remove_copy_if_result, _Out> operator()(_Range&& __r, _Out __result, _Pred __pred, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result), std::move(__pred), std::move(__proj)); } }; inline constexpr __remove_copy_if_fn remove_copy_if{}; template using remove_copy_result = in_out_result<_Iter, _Out>; struct __remove_copy_fn { template _Sent, weakly_incrementable _Out, typename _Tp, typename _Proj = identity> requires indirectly_copyable<_Iter, _Out> && indirect_binary_predicate, const _Tp*> constexpr remove_copy_result<_Iter, _Out> operator()(_Iter __first, _Sent __last, _Out __result, const _Tp& __value, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (!(std::__invoke(__proj, *__first) == __value)) { *__result = *__first; ++__result; } return {std::move(__first), std::move(__result)}; } template requires indirectly_copyable, _Out> && indirect_binary_predicate, _Proj>, const _Tp*> constexpr remove_copy_result, _Out> operator()(_Range&& __r, _Out __result, const _Tp& __value, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result), __value, std::move(__proj)); } }; inline constexpr __remove_copy_fn remove_copy{}; struct __unique_fn { template _Sent, typename _Proj = identity, indirect_equivalence_relation< projected<_Iter, _Proj>> _Comp = ranges::equal_to> constexpr subrange<_Iter> operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { __first = ranges::adjacent_find(__first, __last, __comp, __proj); if (__first == __last) return {__first, __first}; auto __dest = __first; ++__first; while (++__first != __last) if (!std::__invoke(__comp, std::__invoke(__proj, *__dest), std::__invoke(__proj, *__first))) *++__dest = std::move(*__first); return {++__dest, __first}; } template, _Proj>> _Comp = ranges::equal_to> requires permutable> constexpr borrowed_subrange_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __unique_fn unique{}; template using unique_copy_result = in_out_result<_Iter, _Out>; struct __unique_copy_fn { template _Sent, weakly_incrementable _Out, typename _Proj = identity, indirect_equivalence_relation< projected<_Iter, _Proj>> _Comp = ranges::equal_to> requires indirectly_copyable<_Iter, _Out> && (forward_iterator<_Iter> || (input_iterator<_Out> && same_as, iter_value_t<_Out>>) || indirectly_copyable_storable<_Iter, _Out>) constexpr unique_copy_result<_Iter, _Out> operator()(_Iter __first, _Sent __last, _Out __result, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return {std::move(__first), std::move(__result)}; if constexpr (forward_iterator<_Iter>) { auto __next = __first; *__result = *__next; while (++__next != __last) if (!std::__invoke(__comp, std::__invoke(__proj, *__first), std::__invoke(__proj, *__next))) { __first = __next; *++__result = *__first; } return {__next, std::move(++__result)}; } else if constexpr (input_iterator<_Out> && same_as, iter_value_t<_Out>>) { *__result = *__first; while (++__first != __last) if (!std::__invoke(__comp, std::__invoke(__proj, *__result), std::__invoke(__proj, *__first))) *++__result = *__first; return {std::move(__first), std::move(++__result)}; } else { auto __value = *__first; *__result = __value; while (++__first != __last) { if (!(bool)std::__invoke(__comp, std::__invoke(__proj, *__first), std::__invoke(__proj, __value))) { __value = *__first; *++__result = __value; } } return {std::move(__first), std::move(++__result)}; } } template, _Proj>> _Comp = ranges::equal_to> requires indirectly_copyable, _Out> && (forward_iterator> || (input_iterator<_Out> && same_as, iter_value_t<_Out>>) || indirectly_copyable_storable, _Out>) constexpr unique_copy_result, _Out> operator()(_Range&& __r, _Out __result, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result), std::move(__comp), std::move(__proj)); } }; inline constexpr __unique_copy_fn unique_copy{}; struct __reverse_fn { template _Sent> requires permutable<_Iter> constexpr _Iter operator()(_Iter __first, _Sent __last) const { auto __i = ranges::next(__first, __last); auto __tail = __i; if constexpr (random_access_iterator<_Iter>) { if (__first != __last) { --__tail; while (__first < __tail) { ranges::iter_swap(__first, __tail); ++__first; --__tail; } } return __i; } else { for (;;) if (__first == __tail || __first == --__tail) break; else { ranges::iter_swap(__first, __tail); ++__first; } return __i; } } template requires permutable> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r) const { return (*this)(ranges::begin(__r), ranges::end(__r)); } }; inline constexpr __reverse_fn reverse{}; template using reverse_copy_result = in_out_result<_Iter, _Out>; struct __reverse_copy_fn { template _Sent, weakly_incrementable _Out> requires indirectly_copyable<_Iter, _Out> constexpr reverse_copy_result<_Iter, _Out> operator()(_Iter __first, _Sent __last, _Out __result) const { auto __i = ranges::next(__first, __last); auto __tail = __i; while (__first != __tail) { --__tail; *__result = *__tail; ++__result; } return {__i, __result}; } template requires indirectly_copyable, _Out> constexpr reverse_copy_result, _Out> operator()(_Range&& __r, _Out __result) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__result)); } }; inline constexpr __reverse_copy_fn reverse_copy{}; struct __rotate_fn { template _Sent> constexpr subrange<_Iter> operator()(_Iter __first, _Iter __middle, _Sent __last) const { auto __lasti = ranges::next(__first, __last); if (__first == __middle) return {__lasti, __lasti}; if (__last == __middle) return {std::move(__first), std::move(__lasti)}; if constexpr (random_access_iterator<_Iter>) { auto __n = __lasti - __first; auto __k = __middle - __first; if (__k == __n - __k) { ranges::swap_ranges(__first, __middle, __middle, __middle + __k); return {std::move(__middle), std::move(__lasti)}; } auto __p = __first; auto __ret = __first + (__lasti - __middle); for (;;) { if (__k < __n - __k) { if constexpr (__is_pod(iter_value_t<_Iter>)) if (__k == 1) { auto __t = std::move(*__p); ranges::move(__p + 1, __p + __n, __p); *(__p + __n - 1) = std::move(__t); return {std::move(__ret), std::move(__lasti)}; } auto __q = __p + __k; for (decltype(__n) __i = 0; __i < __n - __k; ++ __i) { ranges::iter_swap(__p, __q); ++__p; ++__q; } __n %= __k; if (__n == 0) return {std::move(__ret), std::move(__lasti)}; ranges::swap(__n, __k); __k = __n - __k; } else { __k = __n - __k; if constexpr (__is_pod(iter_value_t<_Iter>)) if (__k == 1) { auto __t = std::move(*(__p + __n - 1)); ranges::move_backward(__p, __p + __n - 1, __p + __n); *__p = std::move(__t); return {std::move(__ret), std::move(__lasti)}; } auto __q = __p + __n; __p = __q - __k; for (decltype(__n) __i = 0; __i < __n - __k; ++ __i) { --__p; --__q; ranges::iter_swap(__p, __q); } __n %= __k; if (__n == 0) return {std::move(__ret), std::move(__lasti)}; std::swap(__n, __k); } } } else if constexpr (bidirectional_iterator<_Iter>) { auto __tail = __lasti; ranges::reverse(__first, __middle); ranges::reverse(__middle, __tail); while (__first != __middle && __middle != __tail) { ranges::iter_swap(__first, --__tail); ++__first; } if (__first == __middle) { ranges::reverse(__middle, __tail); return {std::move(__tail), std::move(__lasti)}; } else { ranges::reverse(__first, __middle); return {std::move(__first), std::move(__lasti)}; } } else { auto __first2 = __middle; do { ranges::iter_swap(__first, __first2); ++__first; ++__first2; if (__first == __middle) __middle = __first2; } while (__first2 != __last); auto __ret = __first; __first2 = __middle; while (__first2 != __last) { ranges::iter_swap(__first, __first2); ++__first; ++__first2; if (__first == __middle) __middle = __first2; else if (__first2 == __last) __first2 = __middle; } return {std::move(__ret), std::move(__lasti)}; } } template requires permutable> constexpr borrowed_subrange_t<_Range> operator()(_Range&& __r, iterator_t<_Range> __middle) const { return (*this)(ranges::begin(__r), std::move(__middle), ranges::end(__r)); } }; inline constexpr __rotate_fn rotate{}; template using rotate_copy_result = in_out_result<_Iter, _Out>; struct __rotate_copy_fn { template _Sent, weakly_incrementable _Out> requires indirectly_copyable<_Iter, _Out> constexpr rotate_copy_result<_Iter, _Out> operator()(_Iter __first, _Iter __middle, _Sent __last, _Out __result) const { auto __copy1 = ranges::copy(__middle, std::move(__last), std::move(__result)); auto __copy2 = ranges::copy(std::move(__first), std::move(__middle), std::move(__copy1.out)); return { std::move(__copy1.in), std::move(__copy2.out) }; } template requires indirectly_copyable, _Out> constexpr rotate_copy_result, _Out> operator()(_Range&& __r, iterator_t<_Range> __middle, _Out __result) const { return (*this)(ranges::begin(__r), std::move(__middle), ranges::end(__r), std::move(__result)); } }; inline constexpr __rotate_copy_fn rotate_copy{}; struct __sample_fn { template _Sent, weakly_incrementable _Out, typename _Gen> requires (forward_iterator<_Iter> || random_access_iterator<_Out>) && indirectly_copyable<_Iter, _Out> && uniform_random_bit_generator> _Out operator()(_Iter __first, _Sent __last, _Out __out, iter_difference_t<_Iter> __n, _Gen&& __g) const { if constexpr (forward_iterator<_Iter>) { auto __lasti = ranges::next(__first, __last); return std::sample(std::move(__first), std::move(__lasti), std::move(__out), __n, std::forward<_Gen>(__g)); } else { using __distrib_type = uniform_int_distribution>; using __param_type = typename __distrib_type::param_type; __distrib_type __d{}; iter_difference_t<_Iter> __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 requires (forward_range<_Range> || random_access_iterator<_Out>) && indirectly_copyable, _Out> && uniform_random_bit_generator> _Out operator()(_Range&& __r, _Out __out, range_difference_t<_Range> __n, _Gen&& __g) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__out), __n, std::forward<_Gen>(__g)); } }; inline constexpr __sample_fn sample{}; struct __shuffle_fn { template _Sent, typename _Gen> requires permutable<_Iter> && uniform_random_bit_generator> _Iter operator()(_Iter __first, _Sent __last, _Gen&& __g) const { auto __lasti = ranges::next(__first, __last); std::shuffle(std::move(__first), __lasti, std::forward<_Gen>(__g)); return __lasti; } template requires permutable> && uniform_random_bit_generator> borrowed_iterator_t<_Range> operator()(_Range&& __r, _Gen&& __g) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::forward<_Gen>(__g)); } }; inline constexpr __shuffle_fn shuffle{}; struct __push_heap_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::push_heap(__first, __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __push_heap_fn push_heap{}; struct __pop_heap_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::pop_heap(__first, __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __pop_heap_fn pop_heap{}; struct __make_heap_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::make_heap(__first, __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __make_heap_fn make_heap{}; struct __sort_heap_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::sort_heap(__first, __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __sort_heap_fn sort_heap{}; struct __is_heap_until_fn { template _Sent, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { iter_difference_t<_Iter> __n = ranges::distance(__first, __last); iter_difference_t<_Iter> __parent = 0, __child = 1; for (; __child < __n; ++__child) if (std::__invoke(__comp, std::__invoke(__proj, *(__first + __parent)), std::__invoke(__proj, *(__first + __child)))) return __first + __child; else if ((__child & 1) == 0) ++__parent; return __first + __n; } template, _Proj>> _Comp = ranges::less> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __is_heap_until_fn is_heap_until{}; struct __is_heap_fn { template _Sent, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr bool operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { return (__last == ranges::is_heap_until(__first, __last, std::move(__comp), std::move(__proj))); } template, _Proj>> _Comp = ranges::less> constexpr bool operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __is_heap_fn is_heap{}; struct __sort_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::sort(std::move(__first), __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __sort_fn sort{}; struct __stable_sort_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::stable_sort(std::move(__first), __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __stable_sort_fn stable_sort{}; struct __partial_sort_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr _Iter operator()(_Iter __first, _Iter __middle, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __middle) return ranges::next(__first, __last); ranges::make_heap(__first, __middle, __comp, __proj); auto __i = __middle; for (; __i != __last; ++__i) if (std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *__first))) { ranges::pop_heap(__first, __middle, __comp, __proj); ranges::iter_swap(__middle-1, __i); ranges::push_heap(__first, __middle, __comp, __proj); } ranges::sort_heap(__first, __middle, __comp, __proj); return __i; } template requires sortable, _Comp, _Proj> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, iterator_t<_Range> __middle, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), std::move(__middle), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __partial_sort_fn partial_sort{}; template using partial_sort_copy_result = in_out_result<_Iter, _Out>; struct __partial_sort_copy_fn { template _Sent1, random_access_iterator _Iter2, sentinel_for<_Iter2> _Sent2, typename _Comp = ranges::less, typename _Proj1 = identity, typename _Proj2 = identity> requires indirectly_copyable<_Iter1, _Iter2> && sortable<_Iter2, _Comp, _Proj2> && indirect_strict_weak_order<_Comp, projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>> constexpr partial_sort_copy_result<_Iter1, _Iter2> operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result_first, _Sent2 __result_last, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { if (__result_first == __result_last) { auto __lasti = ranges::next(std::move(__first), std::move(__last)); return {std::move(__lasti), std::move(__result_first)}; } auto __result_real_last = __result_first; while (__first != __last && __result_real_last != __result_last) { *__result_real_last = *__first; ++__result_real_last; ++__first; } ranges::make_heap(__result_first, __result_real_last, __comp, __proj2); for (; __first != __last; ++__first) if (std::__invoke(__comp, std::__invoke(__proj1, *__first), std::__invoke(__proj2, *__result_first))) { ranges::pop_heap(__result_first, __result_real_last, __comp, __proj2); *(__result_real_last-1) = *__first; ranges::push_heap(__result_first, __result_real_last, __comp, __proj2); } ranges::sort_heap(__result_first, __result_real_last, __comp, __proj2); return {std::move(__first), std::move(__result_real_last)}; } template requires indirectly_copyable, iterator_t<_Range2>> && sortable, _Comp, _Proj2> && indirect_strict_weak_order<_Comp, projected, _Proj1>, projected, _Proj2>> constexpr partial_sort_copy_result, borrowed_iterator_t<_Range2>> operator()(_Range1&& __r, _Range2&& __out, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), ranges::begin(__out), ranges::end(__out), std::move(__comp), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __partial_sort_copy_fn partial_sort_copy{}; struct __is_sorted_until_fn { template _Sent, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return __first; auto __next = __first; for (++__next; __next != __last; __first = __next, (void)++__next) if (std::__invoke(__comp, std::__invoke(__proj, *__next), std::__invoke(__proj, *__first))) return __next; return __next; } template, _Proj>> _Comp = ranges::less> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __is_sorted_until_fn is_sorted_until{}; struct __is_sorted_fn { template _Sent, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr bool operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return true; auto __next = __first; for (++__next; __next != __last; __first = __next, (void)++__next) if (std::__invoke(__comp, std::__invoke(__proj, *__next), std::__invoke(__proj, *__first))) return false; return true; } template, _Proj>> _Comp = ranges::less> constexpr bool operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __is_sorted_fn is_sorted{}; struct __nth_element_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr _Iter operator()(_Iter __first, _Iter __nth, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::nth_element(std::move(__first), std::move(__nth), __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, iterator_t<_Range> __nth, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), std::move(__nth), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __nth_element_fn nth_element{}; struct __lower_bound_fn { template _Sent, typename _Tp, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr _Iter operator()(_Iter __first, _Sent __last, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { auto __len = ranges::distance(__first, __last); while (__len > 0) { auto __half = __len / 2; auto __middle = __first; ranges::advance(__middle, __half); if (std::__invoke(__comp, std::__invoke(__proj, *__middle), __value)) { __first = __middle; ++__first; __len = __len - __half - 1; } else __len = __half; } return __first; } template, _Proj>> _Comp = ranges::less> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), __value, std::move(__comp), std::move(__proj)); } }; inline constexpr __lower_bound_fn lower_bound{}; struct __upper_bound_fn { template _Sent, typename _Tp, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr _Iter operator()(_Iter __first, _Sent __last, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { auto __len = ranges::distance(__first, __last); while (__len > 0) { auto __half = __len / 2; auto __middle = __first; ranges::advance(__middle, __half); if (std::__invoke(__comp, __value, std::__invoke(__proj, *__middle))) __len = __half; else { __first = __middle; ++__first; __len = __len - __half - 1; } } return __first; } template, _Proj>> _Comp = ranges::less> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), __value, std::move(__comp), std::move(__proj)); } }; inline constexpr __upper_bound_fn upper_bound{}; struct __equal_range_fn { template _Sent, typename _Tp, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr subrange<_Iter> operator()(_Iter __first, _Sent __last, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { auto __len = ranges::distance(__first, __last); while (__len > 0) { auto __half = __len / 2; auto __middle = __first; ranges::advance(__middle, __half); if (std::__invoke(__comp, std::__invoke(__proj, *__middle), __value)) { __first = __middle; ++__first; __len = __len - __half - 1; } else if (std::__invoke(__comp, __value, std::__invoke(__proj, *__middle))) __len = __half; else { auto __left = ranges::lower_bound(__first, __middle, __value, __comp, __proj); ranges::advance(__first, __len); auto __right = ranges::upper_bound(++__middle, __first, __value, __comp, __proj); return {__left, __right}; } } return {__first, __first}; } template, _Proj>> _Comp = ranges::less> constexpr borrowed_subrange_t<_Range> operator()(_Range&& __r, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), __value, std::move(__comp), std::move(__proj)); } }; inline constexpr __equal_range_fn equal_range{}; struct __binary_search_fn { template _Sent, typename _Tp, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr bool operator()(_Iter __first, _Sent __last, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { auto __i = ranges::lower_bound(__first, __last, __value, __comp, __proj); if (__i == __last) return false; return !(bool)std::__invoke(__comp, __value, std::__invoke(__proj, *__i)); } template, _Proj>> _Comp = ranges::less> constexpr bool operator()(_Range&& __r, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), __value, std::move(__comp), std::move(__proj)); } }; inline constexpr __binary_search_fn binary_search{}; struct __is_partitioned_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr bool operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { __first = ranges::find_if_not(std::move(__first), __last, __pred, __proj); if (__first == __last) return true; ++__first; return ranges::none_of(std::move(__first), std::move(__last), std::move(__pred), std::move(__proj)); } template, _Proj>> _Pred> constexpr bool operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__pred), std::move(__proj)); } }; inline constexpr __is_partitioned_fn is_partitioned{}; struct __partition_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr subrange<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { if constexpr (bidirectional_iterator<_Iter>) { auto __lasti = ranges::next(__first, __last); auto __tail = __lasti; for (;;) { for (;;) if (__first == __tail) return {std::move(__first), std::move(__lasti)}; else if (std::__invoke(__pred, std::__invoke(__proj, *__first))) ++__first; else break; --__tail; for (;;) if (__first == __tail) return {std::move(__first), std::move(__lasti)}; else if (!(bool)std::__invoke(__pred, std::__invoke(__proj, *__tail))) --__tail; else break; ranges::iter_swap(__first, __tail); ++__first; } } else { if (__first == __last) return {std::move(__first), std::move(__first)}; while (std::__invoke(__pred, std::__invoke(__proj, *__first))) if (++__first == __last) return {std::move(__first), std::move(__first)}; auto __next = __first; while (++__next != __last) if (std::__invoke(__pred, std::__invoke(__proj, *__next))) { ranges::iter_swap(__first, __next); ++__first; } return {std::move(__first), std::move(__next)}; } } template, _Proj>> _Pred> requires permutable> constexpr borrowed_subrange_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 __partition_fn partition{}; struct __stable_partition_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> requires permutable<_Iter> subrange<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); auto __middle = std::stable_partition(std::move(__first), __lasti, __detail::__make_pred_proj(__pred, __proj)); return {std::move(__middle), std::move(__lasti)}; } template, _Proj>> _Pred> requires permutable> borrowed_subrange_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 __stable_partition_fn stable_partition{}; template struct in_out_out_result { [[no_unique_address]] _Iter in; [[no_unique_address]] _Out1 out1; [[no_unique_address]] _Out2 out2; template requires convertible_to && convertible_to && convertible_to constexpr operator in_out_out_result<_IIter, _OOut1, _OOut2>() const & { return {in, out1, out2}; } template requires convertible_to<_Iter, _IIter> && convertible_to<_Out1, _OOut1> && convertible_to<_Out2, _OOut2> constexpr operator in_out_out_result<_IIter, _OOut1, _OOut2>() && { return {std::move(in), std::move(out1), std::move(out2)}; } }; template using partition_copy_result = in_out_out_result<_Iter, _Out1, _Out2>; struct __partition_copy_fn { template _Sent, weakly_incrementable _Out1, weakly_incrementable _O2, typename _Proj = identity, indirect_unary_predicate> _Pred> requires indirectly_copyable<_Iter, _Out1> && indirectly_copyable<_Iter, _O2> constexpr partition_copy_result<_Iter, _Out1, _O2> operator()(_Iter __first, _Sent __last, _Out1 __out_true, _O2 __out_false, _Pred __pred, _Proj __proj = {}) const { for (; __first != __last; ++__first) if (std::__invoke(__pred, std::__invoke(__proj, *__first))) { *__out_true = *__first; ++__out_true; } else { *__out_false = *__first; ++__out_false; } return {std::move(__first), std::move(__out_true), std::move(__out_false)}; } template, _Proj>> _Pred> requires indirectly_copyable, _Out1> && indirectly_copyable, _O2> constexpr partition_copy_result, _Out1, _O2> operator()(_Range&& __r, _Out1 out_true, _O2 out_false, _Pred __pred, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(out_true), std::move(out_false), std::move(__pred), std::move(__proj)); } }; inline constexpr __partition_copy_fn partition_copy{}; struct __partition_point_fn { template _Sent, typename _Proj = identity, indirect_unary_predicate> _Pred> constexpr _Iter operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const { auto __len = ranges::distance(__first, __last); while (__len > 0) { auto __half = __len / 2; auto __middle = __first; ranges::advance(__middle, __half); if (std::__invoke(__pred, std::__invoke(__proj, *__middle))) { __first = __middle; ++__first; __len = __len - __half - 1; } else __len = __half; } return __first; } template, _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 __partition_point_fn partition_point{}; template using merge_result = in_in_out_result<_Iter1, _Iter2, _Out>; struct __merge_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, weakly_incrementable _Out, typename _Comp = ranges::less, typename _Proj1 = identity, typename _Proj2 = identity> requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2> constexpr merge_result<_Iter1, _Iter2, _Out> operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { while (__first1 != __last1 && __first2 != __last2) { if (std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) { *__result = *__first2; ++__first2; } else { *__result = *__first1; ++__first1; } ++__result; } auto __copy1 = ranges::copy(std::move(__first1), std::move(__last1), std::move(__result)); auto __copy2 = ranges::copy(std::move(__first2), std::move(__last2), std::move(__copy1.out)); return { std::move(__copy1.in), std::move(__copy2.in), std::move(__copy2.out) }; } template requires mergeable, iterator_t<_Range2>, _Out, _Comp, _Proj1, _Proj2> constexpr merge_result, borrowed_iterator_t<_Range2>, _Out> operator()(_Range1&& __r1, _Range2&& __r2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__result), std::move(__comp), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __merge_fn merge{}; struct __inplace_merge_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> _Iter operator()(_Iter __first, _Iter __middle, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { auto __lasti = ranges::next(__first, __last); std::inplace_merge(std::move(__first), std::move(__middle), __lasti, __detail::__make_comp_proj(__comp, __proj)); return __lasti; } template requires sortable, _Comp, _Proj> borrowed_iterator_t<_Range> operator()(_Range&& __r, iterator_t<_Range> __middle, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), std::move(__middle), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __inplace_merge_fn inplace_merge{}; struct __includes_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, typename _Proj1 = identity, typename _Proj2 = identity, indirect_strict_weak_order, projected<_Iter2, _Proj2>> _Comp = ranges::less> constexpr bool operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { while (__first1 != __last1 && __first2 != __last2) if (std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) return false; else if (std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) ++__first1; else { ++__first1; ++__first2; } return __first2 == __last2; } template, _Proj1>, projected, _Proj2>> _Comp = ranges::less> constexpr bool operator()(_Range1&& __r1, _Range2&& __r2, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__comp), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __includes_fn includes{}; template using set_union_result = in_in_out_result<_Iter1, _Iter2, _Out>; struct __set_union_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, weakly_incrementable _Out, typename _Comp = ranges::less, typename _Proj1 = identity, typename _Proj2 = identity> requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2> constexpr set_union_result<_Iter1, _Iter2, _Out> operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { while (__first1 != __last1 && __first2 != __last2) { if (std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) { *__result = *__first1; ++__first1; } else if (std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) { *__result = *__first2; ++__first2; } else { *__result = *__first1; ++__first1; ++__first2; } ++__result; } auto __copy1 = ranges::copy(std::move(__first1), std::move(__last1), std::move(__result)); auto __copy2 = ranges::copy(std::move(__first2), std::move(__last2), std::move(__copy1.out)); return {std::move(__copy1.in), std::move(__copy2.in), std::move(__copy2.out)}; } template requires mergeable, iterator_t<_Range2>, _Out, _Comp, _Proj1, _Proj2> constexpr set_union_result, borrowed_iterator_t<_Range2>, _Out> operator()(_Range1&& __r1, _Range2&& __r2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__result), std::move(__comp), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __set_union_fn set_union{}; template using set_intersection_result = in_in_out_result<_Iter1, _Iter2, _Out>; struct __set_intersection_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, weakly_incrementable _Out, typename _Comp = ranges::less, typename _Proj1 = identity, typename _Proj2 = identity> requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2> constexpr set_intersection_result<_Iter1, _Iter2, _Out> operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { while (__first1 != __last1 && __first2 != __last2) if (std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) ++__first1; else if (std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) ++__first2; else { *__result = *__first1; ++__first1; ++__first2; ++__result; } auto __last1i = ranges::next(std::move(__first1), std::move(__last1)); auto __last2i = ranges::next(std::move(__first2), std::move(__last2)); return {std::move(__last1i), std::move(__last2i), std::move(__result)}; } template requires mergeable, iterator_t<_Range2>, _Out, _Comp, _Proj1, _Proj2> constexpr set_intersection_result, borrowed_iterator_t<_Range2>, _Out> operator()(_Range1&& __r1, _Range2&& __r2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__result), std::move(__comp), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __set_intersection_fn set_intersection{}; template using set_difference_result = in_out_result<_Iter, _Out>; struct __set_difference_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, weakly_incrementable _Out, typename _Comp = ranges::less, typename _Proj1 = identity, typename _Proj2 = identity> requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2> constexpr set_difference_result<_Iter1, _Out> operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { while (__first1 != __last1 && __first2 != __last2) if (std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) { *__result = *__first1; ++__first1; ++__result; } else if (std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) ++__first2; else { ++__first1; ++__first2; } return ranges::copy(std::move(__first1), std::move(__last1), std::move(__result)); } template requires mergeable, iterator_t<_Range2>, _Out, _Comp, _Proj1, _Proj2> constexpr set_difference_result, _Out> operator()(_Range1&& __r1, _Range2&& __r2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__result), std::move(__comp), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __set_difference_fn set_difference{}; template using set_symmetric_difference_result = in_in_out_result<_Iter1, _Iter2, _Out>; struct __set_symmetric_difference_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, weakly_incrementable _Out, typename _Comp = ranges::less, typename _Proj1 = identity, typename _Proj2 = identity> requires mergeable<_Iter1, _Iter2, _Out, _Comp, _Proj1, _Proj2> constexpr set_symmetric_difference_result<_Iter1, _Iter2, _Out> operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { while (__first1 != __last1 && __first2 != __last2) if (std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) { *__result = *__first1; ++__first1; ++__result; } else if (std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) { *__result = *__first2; ++__first2; ++__result; } else { ++__first1; ++__first2; } auto __copy1 = ranges::copy(std::move(__first1), std::move(__last1), std::move(__result)); auto __copy2 = ranges::copy(std::move(__first2), std::move(__last2), std::move(__copy1.out)); return {std::move(__copy1.in), std::move(__copy2.in), std::move(__copy2.out)}; } template requires mergeable, iterator_t<_Range2>, _Out, _Comp, _Proj1, _Proj2> constexpr set_symmetric_difference_result, borrowed_iterator_t<_Range2>, _Out> operator()(_Range1&& __r1, _Range2&& __r2, _Out __result, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__result), std::move(__comp), std::move(__proj1), std::move(__proj2)); } }; inline constexpr __set_symmetric_difference_fn set_symmetric_difference{}; struct __min_fn { template> _Comp = ranges::less> constexpr const _Tp& operator()(const _Tp& __a, const _Tp& __b, _Comp __comp = {}, _Proj __proj = {}) const { if (std::__invoke(std::move(__comp), std::__invoke(__proj, __b), std::__invoke(__proj, __a))) return __b; else return __a; } template, _Proj>> _Comp = ranges::less> requires indirectly_copyable_storable, 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); ; 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> _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 __max_fn { template> _Comp = ranges::less> constexpr const _Tp& operator()(const _Tp& __a, const _Tp& __b, _Comp __comp = {}, _Proj __proj = {}) const { if (std::__invoke(std::move(__comp), std::__invoke(__proj, __a), std::__invoke(__proj, __b))) return __b; else return __a; } template, _Proj>> _Comp = ranges::less> requires indirectly_copyable_storable, 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); ; auto __result = *__first; while (++__first != __last) { auto __tmp = *__first; if (std::__invoke(__comp, std::__invoke(__proj, __result), std::__invoke(__proj, __tmp))) __result = std::move(__tmp); } return __result; } template> _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 __max_fn max{}; struct __clamp_fn { template> _Comp = ranges::less> constexpr const _Tp& operator()(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Comp __comp = {}, _Proj __proj = {}) const { ; auto&& __proj_val = std::__invoke(__proj, __val); if (std::__invoke(__comp, __proj_val, std::__invoke(__proj, __lo))) return __lo; else if (std::__invoke(__comp, std::__invoke(__proj, __hi), __proj_val)) return __hi; else return __val; } }; inline constexpr __clamp_fn clamp{}; template struct min_max_result { [[no_unique_address]] _Tp min; [[no_unique_address]] _Tp max; template requires convertible_to constexpr operator min_max_result<_Tp2>() const & { return {min, max}; } template requires convertible_to<_Tp, _Tp2> constexpr operator min_max_result<_Tp2>() && { return {std::move(min), std::move(max)}; } }; template using minmax_result = min_max_result<_Tp>; struct __minmax_fn { template> _Comp = ranges::less> constexpr minmax_result operator()(const _Tp& __a, const _Tp& __b, _Comp __comp = {}, _Proj __proj = {}) const { if (std::__invoke(std::move(__comp), std::__invoke(__proj, __b), std::__invoke(__proj, __a))) return {__b, __a}; else return {__a, __b}; } template, _Proj>> _Comp = ranges::less> requires indirectly_copyable_storable, range_value_t<_Range>*> constexpr minmax_result> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { auto __first = ranges::begin(__r); auto __last = ranges::end(__r); ; minmax_result> __result = {*__first, *__first}; while (++__first != __last) { auto __tmp = *__first; if (std::__invoke(__comp, std::__invoke(__proj, __tmp), std::__invoke(__proj, __result.min))) __result.min = std::move(__tmp); if (!(bool)std::__invoke(__comp, std::__invoke(__proj, __tmp), std::__invoke(__proj, __result.max))) __result.max = std::move(__tmp); } return __result; } template> _Comp = ranges::less> constexpr minmax_result<_Tp> operator()(initializer_list<_Tp> __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::subrange(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __minmax_fn minmax{}; struct __min_element_fn { template _Sent, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return __first; auto __i = __first; while (++__i != __last) { if (std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *__first))) __first = __i; } return __first; } template, _Proj>> _Comp = ranges::less> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __min_element_fn min_element{}; struct __max_element_fn { template _Sent, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return __first; auto __i = __first; while (++__i != __last) { if (std::__invoke(__comp, std::__invoke(__proj, *__first), std::__invoke(__proj, *__i))) __first = __i; } return __first; } template, _Proj>> _Comp = ranges::less> constexpr borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __max_element_fn max_element{}; template using minmax_element_result = min_max_result<_Iter>; struct __minmax_element_fn { template _Sent, typename _Proj = identity, indirect_strict_weak_order> _Comp = ranges::less> constexpr minmax_element_result<_Iter> operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return {__first, __first}; minmax_element_result<_Iter> __result = {__first, __first}; auto __i = __first; while (++__i != __last) { if (std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *__result.min))) __result.min = __i; if (!(bool)std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *__result.max))) __result.max = __i; } return __result; } template, _Proj>> _Comp = ranges::less> constexpr minmax_element_result> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __minmax_element_fn minmax_element{}; struct __lexicographical_compare_fn { template _Sent1, input_iterator _Iter2, sentinel_for<_Iter2> _Sent2, typename _Proj1 = identity, typename _Proj2 = identity, indirect_strict_weak_order, projected<_Iter2, _Proj2>> _Comp = ranges::less> constexpr bool operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Comp __comp = {}, _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(__comp), 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(__comp), std::move(__proj1), std::move(__proj2)); else { constexpr bool __sized_iters = (sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent2, _Iter2>); if constexpr (__sized_iters) { using _ValueType1 = iter_value_t<_Iter1>; using _ValueType2 = iter_value_t<_Iter2>; constexpr bool __use_memcmp = (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value && __ptr_to_nonvolatile<_Iter1> && __ptr_to_nonvolatile<_Iter2> && (is_same_v<_Comp, ranges::less> || is_same_v<_Comp, ranges::greater>) && is_same_v<_Proj1, identity> && is_same_v<_Proj2, identity>); if constexpr (__use_memcmp) { const auto __d1 = __last1 - __first1; const auto __d2 = __last2 - __first2; if (const auto __len = std::min(__d1, __d2)) { const auto __c = std::__memcmp(__first1, __first2, __len); if constexpr (is_same_v<_Comp, ranges::less>) { if (__c < 0) return true; if (__c > 0) return false; } else if constexpr (is_same_v<_Comp, ranges::greater>) { if (__c > 0) return true; if (__c < 0) return false; } } return __d1 < __d2; } } for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void) ++__first2) { if (std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2))) return true; if (std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1))) return false; } return __first1 == __last1 && __first2 != __last2; } } template, _Proj1>, projected, _Proj2>> _Comp = ranges::less> constexpr bool operator()(_Range1&& __r1, _Range2&& __r2, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const { return (*this)(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), std::move(__comp), std::move(__proj1), std::move(__proj2)); } private: template> static constexpr bool __ptr_to_nonvolatile = is_pointer_v<_Iter> && !is_volatile_v>; }; inline constexpr __lexicographical_compare_fn lexicographical_compare; template struct in_found_result { [[no_unique_address]] _Iter in; bool found; template requires convertible_to constexpr operator in_found_result<_Iter2>() const & { return {in, found}; } template requires convertible_to<_Iter, _Iter2> constexpr operator in_found_result<_Iter2>() && { return {std::move(in), found}; } }; template using next_permutation_result = in_found_result<_Iter>; struct __next_permutation_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr next_permutation_result<_Iter> operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return {std::move(__first), false}; auto __i = __first; ++__i; if (__i == __last) return {std::move(__i), false}; auto __lasti = ranges::next(__first, __last); __i = __lasti; --__i; for (;;) { auto __ii = __i; --__i; if (std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *__ii))) { auto __j = __lasti; while (!(bool)std::__invoke(__comp, std::__invoke(__proj, *__i), std::__invoke(__proj, *--__j))) ; ranges::iter_swap(__i, __j); ranges::reverse(__ii, __last); return {std::move(__lasti), true}; } if (__i == __first) { ranges::reverse(__first, __last); return {std::move(__lasti), false}; } } } template requires sortable, _Comp, _Proj> constexpr next_permutation_result> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __next_permutation_fn next_permutation{}; template using prev_permutation_result = in_found_result<_Iter>; struct __prev_permutation_fn { template _Sent, typename _Comp = ranges::less, typename _Proj = identity> requires sortable<_Iter, _Comp, _Proj> constexpr prev_permutation_result<_Iter> operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const { if (__first == __last) return {std::move(__first), false}; auto __i = __first; ++__i; if (__i == __last) return {std::move(__i), false}; auto __lasti = ranges::next(__first, __last); __i = __lasti; --__i; for (;;) { auto __ii = __i; --__i; if (std::__invoke(__comp, std::__invoke(__proj, *__ii), std::__invoke(__proj, *__i))) { auto __j = __lasti; while (!(bool)std::__invoke(__comp, std::__invoke(__proj, *--__j), std::__invoke(__proj, *__i))) ; ranges::iter_swap(__i, __j); ranges::reverse(__ii, __last); return {std::move(__lasti), true}; } if (__i == __first) { ranges::reverse(__first, __last); return {std::move(__lasti), false}; } } } template requires sortable, _Comp, _Proj> constexpr prev_permutation_result> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__comp), std::move(__proj)); } }; inline constexpr __prev_permutation_fn prev_permutation{}; } template constexpr _ForwardIterator shift_left(_ForwardIterator __first, _ForwardIterator __last, typename iterator_traits<_ForwardIterator>::difference_type __n) { ; if (__n == 0) return __last; auto __mid = ranges::next(__first, __n, __last); if (__mid == __last) return __first; return std::move(std::move(__mid), std::move(__last), std::move(__first)); } template constexpr _ForwardIterator shift_right(_ForwardIterator __first, _ForwardIterator __last, typename iterator_traits<_ForwardIterator>::difference_type __n) { ; if (__n == 0) return __first; using _Cat = typename iterator_traits<_ForwardIterator>::iterator_category; if constexpr (derived_from<_Cat, bidirectional_iterator_tag>) { auto __mid = ranges::next(__last, -__n, __first); if (__mid == __first) return __last; return std::move_backward(std::move(__first), std::move(__mid), std::move(__last)); } else { auto __result = ranges::next(__first, __n, __last); if (__result == __last) return __last; auto __dest_head = __first, __dest_tail = __result; while (__dest_head != __result) { if (__dest_tail == __last) { std::move(std::move(__first), std::move(__dest_head), std::move(__result)); return __result; } ++__dest_head; ++__dest_tail; } for (;;) { # 3767 "/usr/include/c++/10/bits/ranges_algo.h" 3 auto __cursor = __first; while (__cursor != __result) { if (__dest_tail == __last) { __dest_head = std::move(__cursor, __result, std::move(__dest_head)); std::move(std::move(__first), std::move(__cursor), std::move(__dest_head)); return __result; } std::iter_swap(__cursor, __dest_head); ++__dest_head; ++__dest_tail; ++__cursor; } } } } } # 65 "/usr/include/c++/10/algorithm" 2 3 # 74 "/usr/include/c++/10/algorithm" 3 # 1 "/usr/include/c++/10/pstl/glue_algorithm_defs.h" 1 3 # 17 "/usr/include/c++/10/pstl/glue_algorithm_defs.h" 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::difference_type> count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::difference_type> count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _UnaryOperation __op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator __result, _BinaryOperation __op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, const _Tp& __old_value, const _Tp& __new_value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Predicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _ForwardIterator __d_first); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __p); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __d_first); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator result, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2); } # 75 "/usr/include/c++/10/algorithm" 2 3 # 70 "all-std.cxx" 2 # 1 "/usr/include/c++/10/execution" 1 3 # 28 "/usr/include/c++/10/execution" 3 # 29 "/usr/include/c++/10/execution" 3 # 1 "/usr/include/c++/10/pstl/glue_execution_defs.h" 1 3 # 17 "/usr/include/c++/10/pstl/glue_execution_defs.h" 3 namespace std { using __pstl::execution::is_execution_policy; using __pstl::execution::is_execution_policy_v; namespace execution { using __pstl::execution::parallel_policy; using __pstl::execution::parallel_unsequenced_policy; using __pstl::execution::sequenced_policy; using __pstl::execution::par; using __pstl::execution::par_unseq; using __pstl::execution::seq; using __pstl::execution::unseq; using __pstl::execution::unsequenced_policy; } } # 1 "/usr/include/c++/10/pstl/algorithm_impl.h" 1 3 # 19 "/usr/include/c++/10/pstl/algorithm_impl.h" 3 # 1 "/usr/include/c++/10/pstl/execution_impl.h" 1 3 # 18 "/usr/include/c++/10/pstl/execution_impl.h" 3 namespace __pstl { namespace __internal { using namespace __pstl::execution; template std::false_type __lazy_and(_Tp, std::false_type) { return std::false_type{}; }; template inline _Tp __lazy_and(_Tp __a, std::true_type) { return __a; } template std::true_type __lazy_or(_Tp, std::true_type) { return std::true_type{}; }; template inline _Tp __lazy_or(_Tp __a, std::false_type) { return __a; } template struct __is_random_access_iterator { static constexpr bool value = __internal::__is_random_access_iterator<_IteratorType>::value && __internal::__is_random_access_iterator<_OtherIteratorTypes...>::value; typedef std::integral_constant type; }; template struct __is_random_access_iterator<_IteratorType> : std::is_same::iterator_category, std::random_access_iterator_tag> { }; template struct __policy_traits { }; template <> struct __policy_traits { typedef std::false_type allow_parallel; typedef std::false_type allow_unsequenced; typedef std::false_type allow_vector; }; template <> struct __policy_traits { typedef std::false_type allow_parallel; typedef std::true_type allow_unsequenced; typedef std::true_type allow_vector; }; template <> struct __policy_traits { typedef std::true_type allow_parallel; typedef std::false_type allow_unsequenced; typedef std::false_type allow_vector; }; template <> struct __policy_traits { typedef std::true_type allow_parallel; typedef std::true_type allow_unsequenced; typedef std::true_type allow_vector; }; template using __collector_t = typename __internal::__policy_traits::type>::__collector_type; template using __allow_vector = typename __internal::__policy_traits::type>::__allow_vector; template using __allow_unsequenced = typename __internal::__policy_traits::type>::__allow_unsequenced; template using __allow_parallel = typename __internal::__policy_traits::type>::__allow_parallel; template auto __is_vectorization_preferred(_ExecutionPolicy&& __exec) -> decltype(__internal::__lazy_and(__exec.__allow_vector(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type())) { return __internal::__lazy_and(__exec.__allow_vector(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()); } template auto __is_parallelization_preferred(_ExecutionPolicy&& __exec) -> decltype(__internal::__lazy_and(__exec.__allow_parallel(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type())) { return __internal::__lazy_and(__exec.__allow_parallel(), typename __internal::__is_random_access_iterator<_IteratorTypes...>::type()); } template struct __prefer_unsequenced_tag { static constexpr bool value = __internal::__allow_unsequenced::value && __internal::__is_random_access_iterator<_IteratorTypes...>::value; typedef std::integral_constant type; }; template struct __prefer_parallel_tag { static constexpr bool value = __internal::__allow_parallel::value && __internal::__is_random_access_iterator<_IteratorTypes...>::value; typedef std::integral_constant type; }; } } # 20 "/usr/include/c++/10/pstl/algorithm_impl.h" 2 3 # 1 "/usr/include/c++/10/pstl/memory_impl.h" 1 3 # 15 "/usr/include/c++/10/pstl/memory_impl.h" 3 # 1 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 1 3 # 15 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 # 1 "/usr/include/c++/10/pstl/utils.h" 1 3 # 16 "/usr/include/c++/10/pstl/utils.h" 3 namespace __pstl { namespace __internal { template typename std::result_of<_Fp()>::type __except_handler(_Fp __f) { try { return __f(); } catch (const std::bad_alloc&) { throw; } catch (...) { std::terminate(); } } template void __invoke_if(std::true_type, _Fp __f) { __f(); } template void __invoke_if(std::false_type, _Fp __f) { } template void __invoke_if_not(std::false_type, _Fp __f) { __f(); } template void __invoke_if_not(std::true_type, _Fp __f) { } template typename std::result_of<_F1()>::type __invoke_if_else(std::true_type, _F1 __f1, _F2 __f2) { return __f1(); } template typename std::result_of<_F2()>::type __invoke_if_else(std::false_type, _F1 __f1, _F2 __f2) { return __f2(); } struct __no_op { template _Tp&& operator()(_Tp&& __a) const { return std::forward<_Tp>(__a); } }; template class __not_pred { _Pred _M_pred; public: explicit __not_pred(_Pred __pred) : _M_pred(__pred) {} template bool operator()(_Args&&... __args) { return !_M_pred(std::forward<_Args>(__args)...); } }; template class __reorder_pred { _Pred _M_pred; public: explicit __reorder_pred(_Pred __pred) : _M_pred(__pred) {} template bool operator()(_FTp&& __a, _STp&& __b) { return _M_pred(std::forward<_STp>(__b), std::forward<_FTp>(__a)); } }; class __pstl_equal { public: explicit __pstl_equal() {} template bool operator()(_Xp&& __x, _Yp&& __y) const { return std::forward<_Xp>(__x) == std::forward<_Yp>(__y); } }; class __pstl_less { public: explicit __pstl_less() {} template bool operator()(_Xp&& __x, _Yp&& __y) const { return std::forward<_Xp>(__x) < std::forward<_Yp>(__y); } }; template class __equal_value_by_pred { const _Tp& _M_value; _Predicate _M_pred; public: __equal_value_by_pred(const _Tp& __value, _Predicate __pred) : _M_value(__value), _M_pred(__pred) {} template bool operator()(_Arg&& __arg) { return _M_pred(std::forward<_Arg>(__arg), _M_value); } }; template class __equal_value { const _Tp& _M_value; public: explicit __equal_value(const _Tp& __value) : _M_value(__value) {} template bool operator()(_Arg&& __arg) const { return std::forward<_Arg>(__arg) == _M_value; } }; template class __not_equal_value { const _Tp& _M_value; public: explicit __not_equal_value(const _Tp& __value) : _M_value(__value) {} template bool operator()(_Arg&& __arg) const { return !(std::forward<_Arg>(__arg) == _M_value); } }; template _ForwardIterator __cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp) { if (__a < __b) { return __comp(*__b, *__a) ? __b : __a; } else { return __comp(*__a, *__b) ? __a : __b; } } } } # 16 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 2 3 namespace __pstl { namespace __unseq_backend { const std::size_t __lane_size = 64; template _Iterator __simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept { # 31 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 31 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) __f(__first[__i]); return __first + __n; } template _Iterator2 __simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept { # 42 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 42 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) __f(__first1[__i], __first2[__i]); return __first2 + __n; } template _Iterator3 __simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3, _Function __f) noexcept { # 53 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 53 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) __f(__first1[__i], __first2[__i], __first3[__i]); return __first3 + __n; } template bool __simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept { # 73 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 _DifferenceType __block_size = 4 < __n ? 4 : __n; const _Index __last = __first + __n; while (__last != __first) { int32_t __flag = 1; # 78 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(& : __flag) # 78 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __block_size; ++__i) if (__pred(*(__first + __i))) __flag = 0; if (!__flag) return true; __first += __block_size; if (__last - __first >= __block_size << 1) { __block_size <<= 1; } else { __block_size = __last - __first; } } return false; } template _Index __simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept { # 117 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 const _DifferenceType __block_size = 8; alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; while (__end - __begin >= __block_size) { _DifferenceType __found = 0; #pragma omp simd reduction(| : __found) # 123 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = __begin; __i < __begin + __block_size; ++__i) { const _DifferenceType __t = __comp(__first, __i); __lane[__i - __begin] = __t; __found |= __t; } if (__found) { _DifferenceType __i; for (__i = 0; __i < __block_size; ++__i) { if (__lane[__i]) { break; } } return __first + __begin + __i; } __begin += __block_size; } while (__begin != __end) { if (__comp(__first, __begin)) { return __first + __begin; } ++__begin; } return __first + __end; } template std::pair<_Index1, _Index2> __simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept { # 173 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 const _Index1 __last1 = __first1 + __n; const _Index2 __last2 = __first2 + __n; const _DifferenceType __block_size = 8; alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; while (__last1 - __first1 >= __block_size) { _DifferenceType __found = 0; _DifferenceType __i; #pragma omp simd reduction(| : __found) # 183 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (__i = 0; __i < __block_size; ++__i) { const _DifferenceType __t = __pred(__first1[__i], __first2[__i]); __lane[__i] = __t; __found |= __t; } if (__found) { _DifferenceType __i; for (__i = 0; __i < __block_size; ++__i) { if (__lane[__i]) break; } return std::make_pair(__first1 + __i, __first2 + __i); } __first1 += __block_size; __first2 += __block_size; } for (; __last1 != __first1; ++__first1, ++__first2) if (__pred(*(__first1), *(__first2))) return std::make_pair(__first1, __first2); return std::make_pair(__last1, __last2); } template _DifferenceType __simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept { _DifferenceType __count = 0; # 219 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(+ : __count) # 219 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) if (__pred(*(__index + __i))) ++__count; return __count; } template _OutputIterator __simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _BinaryPredicate __pred) noexcept { if (__n == 0) return __result; _DifferenceType __cnt = 1; __result[0] = __first[0]; # 238 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 238 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 1; __i < __n; ++__i) { if (!__pred(__first[__i], __first[__i - 1])) { __result[__cnt] = __first[__i]; ++__cnt; } } return __result + __cnt; } template _OutputIterator __simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept { # 256 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 256 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) __assigner(__first + __i, __result + __i); return __result + __n; } template _OutputIterator __simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept { _DifferenceType __cnt = 0; # 268 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 268 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) { if (__pred(__first[__i])) { __result[__cnt] = __first[__i]; ++__cnt; } } return __result + __cnt; } template _DifferenceType __simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept { _DifferenceType __count = 0; # 287 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(+ : __count) # 287 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) { __mask[__i] = !__pred(__first[__i], __first[__i - 1]); __count += __mask[__i]; } return __count; } template _DifferenceType __simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept { _DifferenceType __count = 0; # 302 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(+ : __count) # 302 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) { __mask[__i] = __pred(__first[__i]); __count += __mask[__i]; } return __count; } template void __simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask, _Assigner __assigner) noexcept { _DifferenceType __cnt = 0; # 317 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 317 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) { if (__mask[__i]) { { __assigner(__first + __i, __result + __cnt); ++__cnt; } } } } template void __simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true, _OutputIterator2 __out_false, bool* __mask) noexcept { _DifferenceType __cnt_true = 0, __cnt_false = 0; # 337 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 337 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) { if (__mask[__i]) { __out_true[__cnt_true] = __first[__i]; ++__cnt_true; } else { __out_false[__cnt_false] = __first[__i]; ++__cnt_false; } } } template _Index __simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept { # 359 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 359 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) __first[__i] = __value; return __first + __n; } template _Index __simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept { # 370 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 370 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __size; ++__i) __first[__i] = __g(); return __first + __size; } template _Index __simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept { if (__last - __first < 2) return __last; typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType; _DifferenceType __i = 0; # 399 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 const _DifferenceType __block_size = 8; alignas(__lane_size) _DifferenceType __lane[__block_size] = {0}; while (__last - __first >= __block_size) { _DifferenceType __found = 0; #pragma omp simd reduction(| : __found) # 405 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (__i = 0; __i < __block_size - 1; ++__i) { const _DifferenceType __t = __pred(*(__first + __i), *(__first + __i + 1)); __lane[__i] = __t; __found |= __t; } if (__first + __block_size < __last && __pred(*(__first + __i), *(__first + __i + 1))) __lane[__i] = __found = 1; if (__found) { if (__or_semantic) return __first; for (__i = 0; __i < __block_size; ++__i) if (__lane[__i]) break; return __first + __i; } __first += __block_size; } for (; __last - __first > 1; ++__first) if (__pred(*__first, *(__first + 1))) return __first; return __last; } template using is_arithmetic_plus = std::integral_constant::value && std::is_same<_BinaryOperation, std::plus<_Tp>>::value>; template typename std::enable_if::value, _Tp>::type __simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept { # 449 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(+ : __init) # 449 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) __init += __f(__i); return __init; } template typename std::enable_if::value, _Tp>::type __simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept { const _Size __block_size = __lane_size / sizeof(_Tp); if (__n > 2 * __block_size && __block_size > 1) { alignas(__lane_size) char __lane_[__lane_size]; _Tp* __lane = reinterpret_cast<_Tp*>(__lane_); # 466 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 466 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 0; __i < __block_size; ++__i) { ::new (__lane + __i) _Tp(__binary_op(__f(__i), __f(__block_size + __i))); } _Size __i = 2 * __block_size; const _Size last_iteration = __block_size * (__n / __block_size); for (; __i < last_iteration; __i += __block_size) { # 476 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 476 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __j = 0; __j < __block_size; ++__j) { __lane[__j] = __binary_op(__lane[__j], __f(__i + __j)); } } # 483 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 483 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __j = 0; __j < __n - last_iteration; ++__j) { __lane[__j] = __binary_op(__lane[__j], __f(last_iteration + __j)); } for (_Size __i = 0; __i < __block_size; ++__i) { __init = __binary_op(__init, __lane[__i]); } # 494 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 494 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 0; __i < __block_size; ++__i) { __lane[__i].~_Tp(); } } else { for (_Size __i = 0; __i < __n; ++__i) { __init = __binary_op(__init, __f(__i)); } } return __init; } template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation, std::false_type) { # 517 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(inscan, + : __init) # 517 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 0; __i < __n; ++__i) { __result[__i] = __init; # 521 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp scan exclusive(__init) # 521 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 __init += __unary_op(__first[__i]); } return std::make_pair(__result + __n, __init); } template struct _Combiner { _Tp __value; _BinaryOp* __bin_op; _Combiner() : __value{}, __bin_op(nullptr) {} _Combiner(const _Tp& value, const _BinaryOp* bin_op) : __value(value), __bin_op(const_cast<_BinaryOp*>(bin_op)) {} _Combiner(const _Combiner& __obj) : __value{}, __bin_op(__obj.__bin_op) {} void operator()(const _Combiner& __obj) { __value = (*__bin_op)(__value, __obj.__value); } }; template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, std::false_type) { typedef _Combiner<_Tp, _BinaryOperation> _CombinerType; _CombinerType __init_{__init, &__binary_op}; # 555 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp declare reduction(__bin_op:_CombinerType : omp_out(omp_in)) initializer(omp_priv = omp_orig) # 555 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 # 557 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(inscan, __bin_op : __init_) # 557 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 0; __i < __n; ++__i) { __result[__i] = __init_.__value; # 561 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp scan exclusive(__init_) # 561 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i])); } return std::make_pair(__result + __n, __init_.__value); } template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation, std::true_type) { # 575 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(inscan, + : __init) # 575 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 0; __i < __n; ++__i) { __init += __unary_op(__first[__i]); # 579 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp scan inclusive(__init) # 579 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 __result[__i] = __init; } return std::make_pair(__result + __n, __init); } template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type __simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, std::true_type) { typedef _Combiner<_Tp, _BinaryOperation> _CombinerType; _CombinerType __init_{__init, &__binary_op}; # 595 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp declare reduction(__bin_op:_CombinerType : omp_out(omp_in)) initializer(omp_priv = omp_orig) # 595 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 # 597 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(inscan, __bin_op : __init_) # 597 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 0; __i < __n; ++__i) { __init_.__value = __binary_op(__init_.__value, __unary_op(__first[__i])); # 602 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp scan inclusive(__init_) # 602 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 __result[__i] = __init_.__value; } return std::make_pair(__result + __n, __init_.__value); } template _ForwardIterator __simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept { if (__n == 0) { return __first; } typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType; struct _ComplexType { _ValueType __min_val; _Size __min_ind; _Compare* __min_comp; _ComplexType() : __min_val{}, __min_ind{}, __min_comp(nullptr) {} _ComplexType(const _ValueType& val, const _Compare* comp) : __min_val(val), __min_ind(0), __min_comp(const_cast<_Compare*>(comp)) { } _ComplexType(const _ComplexType& __obj) : __min_val(__obj.__min_val), __min_ind(__obj.__min_ind), __min_comp(__obj.__min_comp) { } # 636 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp declare simd # 636 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 void operator()(const _ComplexType& __obj) { if (!(*__min_comp)(__min_val, __obj.__min_val) && ((*__min_comp)(__obj.__min_val, __min_val) || __obj.__min_ind - __min_ind < 0)) { __min_val = __obj.__min_val; __min_ind = __obj.__min_ind; } } }; _ComplexType __init{*__first, &__comp}; # 651 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp declare reduction(__min_func:_ComplexType : omp_out(omp_in)) initializer(omp_priv = omp_orig) # 651 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 # 653 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(__min_func : __init) # 653 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 1; __i < __n; ++__i) { const _ValueType __min_val = __init.__min_val; const _ValueType __current = __first[__i]; if (__comp(__current, __min_val)) { __init.__min_val = __current; __init.__min_ind = __i; } } return __first + __init.__min_ind; } template std::pair<_ForwardIterator, _ForwardIterator> __simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept { if (__n == 0) { return std::make_pair(__first, __first); } typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType; struct _ComplexType { _ValueType __min_val; _ValueType __max_val; _Size __min_ind; _Size __max_ind; _Compare* __minmax_comp; _ComplexType() : __min_val{}, __max_val{}, __min_ind{}, __max_ind{}, __minmax_comp(nullptr) {} _ComplexType(const _ValueType& min_val, const _ValueType& max_val, const _Compare* comp) : __min_val(min_val), __max_val(max_val), __min_ind(0), __max_ind(0), __minmax_comp(const_cast<_Compare*>(comp)) { } _ComplexType(const _ComplexType& __obj) : __min_val(__obj.__min_val), __max_val(__obj.__max_val), __min_ind(__obj.__min_ind), __max_ind(__obj.__max_ind), __minmax_comp(__obj.__minmax_comp) { } void operator()(const _ComplexType& __obj) { if ((*__minmax_comp)(__obj.__min_val, __min_val)) { __min_val = __obj.__min_val; __min_ind = __obj.__min_ind; } else if (!(*__minmax_comp)(__min_val, __obj.__min_val)) { __min_val = __obj.__min_val; __min_ind = (__min_ind - __obj.__min_ind < 0) ? __min_ind : __obj.__min_ind; } if ((*__minmax_comp)(__max_val, __obj.__max_val)) { __max_val = __obj.__max_val; __max_ind = __obj.__max_ind; } else if (!(*__minmax_comp)(__obj.__max_val, __max_val)) { __max_val = __obj.__max_val; __max_ind = (__max_ind - __obj.__max_ind < 0) ? __obj.__max_ind : __max_ind; } } }; _ComplexType __init{*__first, *__first, &__comp}; # 730 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp declare reduction(__min_func:_ComplexType : omp_out(omp_in)) initializer(omp_priv = omp_orig) # 730 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 ; # 732 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd reduction(__min_func : __init) # 732 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_Size __i = 1; __i < __n; ++__i) { auto __min_val = __init.__min_val; auto __max_val = __init.__max_val; auto __current = __first + __i; if (__comp(*__current, __min_val)) { __init.__min_val = *__current; __init.__min_ind = __i; } else if (!__comp(*__current, __max_val)) { __init.__max_val = *__current; __init.__max_ind = __i; } } return std::make_pair(__first + __init.__min_ind, __first + __init.__max_ind); } template std::pair<_OutputIterator1, _OutputIterator2> __simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept { _DifferenceType __cnt_true = 0, __cnt_false = 0; # 760 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 760 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 0; __i < __n; ++__i) { if (__pred(__first[__i])) { __out_true[__cnt_true] = __first[__i]; ++__cnt_true; } else { __out_false[__cnt_false] = __first[__i]; ++__cnt_false; } } return std::make_pair(__out_true + __cnt_true, __out_false + __cnt_false); } template _ForwardIterator1 __simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred) noexcept { typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferencType; const _DifferencType __n1 = __last - __first; const _DifferencType __n2 = __s_last - __s_first; if (__n1 == 0 || __n2 == 0) { return __last; } if (__n1 < __n2) { for (; __first != __last; ++__first) { if (__unseq_backend::__simd_or(__s_first, __n2, __internal::__equal_value_by_pred(*__first, __pred))) { return __first; } } } else { for (; __s_first != __s_last; ++__s_first) { const auto __result = __unseq_backend::__simd_first(__first, _DifferencType(0), __n1, [__s_first, &__pred](_ForwardIterator1 __it, _DifferencType __i) { return __pred(__it[__i], *__s_first); }); if (__result != __last) { return __result; } } } return __last; } template _RandomAccessIterator __simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept { auto __current = __unseq_backend::__simd_first(__first, _DifferenceType(0), __n, [&__pred](_RandomAccessIterator __it, _DifferenceType __i) { return __pred(__it[__i]); }); __n -= __current - __first; if (__n < 2) { return __current; } _DifferenceType __cnt = 0; # 840 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 #pragma omp simd # 840 "/usr/include/c++/10/pstl/unseq_backend_simd.h" 3 for (_DifferenceType __i = 1; __i < __n; ++__i) { if (!__pred(__current[__i])) { __current[__cnt] = std::move(__current[__i]); ++__cnt; } } return __current + __cnt; } } } # 16 "/usr/include/c++/10/pstl/memory_impl.h" 2 3 namespace __pstl { namespace __internal { template _OutputIterator __brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::false_type) noexcept { typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType2; for (; __first != __last; ++__first, ++__result) { ::new (std::addressof(*__result)) _ValueType2(std::move(*__first)); } return __result; } template _OutputIterator __brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::true_type) noexcept { typedef typename std::iterator_traits<_OutputIterator>::value_type __ValueType2; typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType1; typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2; return __unseq_backend::__simd_walk_2( __first, __last - __first, __result, [](_ReferenceType1 __x, _ReferenceType2 __y) { ::new (std::addressof(__y)) __ValueType2(std::move(__x)); }); } } } # 21 "/usr/include/c++/10/pstl/algorithm_impl.h" 2 3 # 1 "/usr/include/c++/10/pstl/parallel_backend_utils.h" 1 3 # 17 "/usr/include/c++/10/pstl/parallel_backend_utils.h" 3 namespace __pstl { namespace __par_backend { struct __serial_destroy { template void operator()(_RandomAccessIterator __zs, _RandomAccessIterator __ze) { typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType; while (__zs != __ze) { --__ze; (*__ze).~_ValueType(); } } }; template struct __serial_move_merge { const std::size_t _M_nmerge; _MoveValues _M_move_values; _MoveSequences _M_move_sequences; explicit __serial_move_merge(std::size_t __nmerge, _MoveValues __move_values, _MoveSequences __move_sequences) : _M_nmerge(__nmerge), _M_move_values(__move_values), _M_move_sequences(__move_sequences) { } template void operator()(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp) { auto __n = _M_nmerge; ; if (__xs != __xe) { if (__ys != __ye) { for (;;) { if (__comp(*__ys, *__xs)) { _M_move_values(__ys, __zs); ++__zs, --__n; if (++__ys == __ye) { break; } else if (__n == 0) { __zs = _M_move_sequences(__ys, __ye, __zs); break; } else { } } else { _M_move_values(__xs, __zs); ++__zs, --__n; if (++__xs == __xe) { _M_move_sequences(__ys, __ye, __zs); return; } else if (__n == 0) { __zs = _M_move_sequences(__xs, __xe, __zs); _M_move_sequences(__ys, __ye, __zs); return; } else { } } } } __ys = __xs; __ye = __xe; } _M_move_sequences(__ys, __ye, __zs); } }; template void __init_buf(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _OutputIterator __zs, bool __bMove) { const _OutputIterator __ze = __zs + (__xe - __xs); typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType; if (__bMove) { for (; __zs != __ze; ++__xs, ++__zs) new (&*__zs) _ValueType(std::move(*__xs)); } else { for (; __zs != __ze; ++__zs) new (&*__zs) _ValueType; } } template class __stack { typedef typename std::iterator_traits::value_type _ValueType; typedef typename std::iterator_traits<_ValueType*>::difference_type _DifferenceType; _Buf _M_buf; _ValueType* _M_ptr; _DifferenceType _M_maxsize; __stack(const __stack&) = delete; void operator=(const __stack&) = delete; public: __stack(_DifferenceType __max_size) : _M_buf(__max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); } ~__stack() { ; while (!empty()) pop(); } const _Buf& buffer() const { return _M_buf; } size_t size() const { ; ; return _M_ptr - _M_buf.get(); } bool empty() const { ; return _M_ptr == _M_buf.get(); } void push(const _ValueType& __v) { ; new (_M_ptr) _ValueType(__v); ++_M_ptr; } const _ValueType& top() const { return *(_M_ptr - 1); } void pop() { ; --_M_ptr; (*_M_ptr).~_ValueType(); } }; } } # 22 "/usr/include/c++/10/pstl/algorithm_impl.h" 2 3 # 1 "/usr/include/c++/10/pstl/parallel_backend.h" 1 3 # 14 "/usr/include/c++/10/pstl/parallel_backend.h" 3 # 1 "/usr/include/c++/10/pstl/parallel_backend_serial.h" 1 3 # 16 "/usr/include/c++/10/pstl/parallel_backend_serial.h" 3 # 1 "/usr/include/c++/10/numeric" 1 3 # 58 "/usr/include/c++/10/numeric" 3 # 59 "/usr/include/c++/10/numeric" 3 # 1 "/usr/include/c++/10/bits/stl_numeric.h" 1 3 # 64 "/usr/include/c++/10/bits/stl_numeric.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 85 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr void iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value) { ; for (; __first != __last; ++__first) { *__first = __value; ++__value; } } # 131 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr inline _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init) { ; for (; __first != __last; ++__first) __init = std::move(__init) + *__first; return __init; } # 158 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr inline _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op) { ; for (; __first != __last; ++__first) __init = __binary_op(std::move(__init), *__first); return __init; } # 187 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr inline _Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) { ; for (; __first1 != __last1; ++__first1, (void)++__first2) __init = std::move(__init) + (*__first1 * *__first2); return __init; } # 219 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr inline _Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2) { ; for (; __first1 != __last1; ++__first1, (void)++__first2) __init = __binary_op1(std::move(__init), __binary_op2(*__first1, *__first2)); return __init; } # 253 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr _OutputIterator partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType; ; if (__first == __last) return __result; _ValueType __value = *__first; *__result = __value; while (++__first != __last) { __value = std::move(__value) + *__first; *++__result = __value; } return ++__result; } # 294 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr _OutputIterator partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType; ; if (__first == __last) return __result; _ValueType __value = *__first; *__result = __value; while (++__first != __last) { __value = __binary_op(std::move(__value), *__first); *++__result = __value; } return ++__result; } # 335 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr _OutputIterator adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType; ; if (__first == __last) return __result; _ValueType __value = *__first; *__result = __value; while (++__first != __last) { _ValueType __tmp = *__first; *++__result = __tmp - std::move(__value); __value = std::move(__tmp); } return ++__result; } # 378 "/usr/include/c++/10/bits/stl_numeric.h" 3 template constexpr _OutputIterator adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType; ; if (__first == __last) return __result; _ValueType __value = *__first; *__result = __value; while (++__first != __last) { _ValueType __tmp = *__first; *++__result = __binary_op(__tmp, std::move(__value)); __value = std::move(__tmp); } return ++__result; } } # 63 "/usr/include/c++/10/numeric" 2 3 # 80 "/usr/include/c++/10/numeric" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template constexpr _Up __absu(_Tp __val) { static_assert(is_unsigned<_Up>::value, "result type must be unsigned"); static_assert(sizeof(_Up) >= sizeof(_Tp), "result type must be at least as wide as the input type"); return __val < 0 ? -(_Up)__val : (_Up)__val; } template void __absu(bool) = delete; template constexpr _Tp __gcd(_Tp __m, _Tp __n) { static_assert(is_unsigned<_Tp>::value, "type must be unsigned"); return __m == 0 ? __n : __n == 0 ? __m : __detail::__gcd(__n, _Tp(__m % __n)); } template constexpr _Tp __lcm(_Tp __m, _Tp __n) { return (__m != 0 && __n != 0) ? (__m / __detail::__gcd(__m, __n)) * __n : 0; } } # 130 "/usr/include/c++/10/numeric" 3 template constexpr common_type_t<_Mn, _Nn> gcd(_Mn __m, _Nn __n) noexcept { static_assert(is_integral_v<_Mn>, "std::gcd arguments must be integers"); static_assert(is_integral_v<_Nn>, "std::gcd arguments must be integers"); static_assert(_Mn(2) != _Mn(1), "std::gcd arguments must not be bool"); static_assert(_Nn(2) != _Nn(1), "std::gcd arguments must not be bool"); using _Up = make_unsigned_t>; return __detail::__gcd(__detail::__absu<_Up>(__m), __detail::__absu<_Up>(__n)); } template constexpr common_type_t<_Mn, _Nn> lcm(_Mn __m, _Nn __n) noexcept { static_assert(is_integral_v<_Mn>, "std::lcm arguments must be integers"); static_assert(is_integral_v<_Nn>, "std::lcm arguments must be integers"); static_assert(_Mn(2) == 2, "std::lcm arguments must not be bool"); static_assert(_Nn(2) == 2, "std::lcm arguments must not be bool"); using _Up = make_unsigned_t>; return __detail::__lcm(__detail::__absu<_Up>(__m), __detail::__absu<_Up>(__n)); } } namespace std __attribute__ ((__visibility__ ("default"))) { template constexpr enable_if_t<__and_v, is_same, _Tp>, __not_>>, _Tp> midpoint(_Tp __a, _Tp __b) noexcept { if constexpr (is_integral_v<_Tp>) { using _Up = make_unsigned_t<_Tp>; int __k = 1; _Up __m = __a; _Up __M = __b; if (__a > __b) { __k = -1; __m = __b; __M = __a; } return __a + __k * _Tp(_Up(__M - __m) / 2); } else { constexpr _Tp __lo = numeric_limits<_Tp>::min() * 2; constexpr _Tp __hi = numeric_limits<_Tp>::max() / 2; const _Tp __abs_a = __a < 0 ? -__a : __a; const _Tp __abs_b = __b < 0 ? -__b : __b; if (__abs_a <= __hi && __abs_b <= __hi) [[likely]] return (__a + __b) / 2; if (__abs_a < __lo) return __a + __b/2; if (__abs_b < __lo) return __a/2 + __b; return __a/2 + __b/2; } } template constexpr enable_if_t, _Tp*> midpoint(_Tp* __a, _Tp* __b) noexcept { static_assert( sizeof(_Tp) != 0, "type must be complete" ); return __a + (__b - __a) / 2; } } namespace std __attribute__ ((__visibility__ ("default"))) { # 256 "/usr/include/c++/10/numeric" 3 template constexpr _Tp reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op) { using value_type = typename iterator_traits<_InputIterator>::value_type; static_assert(is_invocable_r_v<_Tp, _BinaryOperation&, _Tp&, _Tp&>); static_assert(is_convertible_v); if constexpr (__is_random_access_iter<_InputIterator>::value) { while ((__last - __first) >= 4) { _Tp __v1 = __binary_op(__first[0], __first[1]); _Tp __v2 = __binary_op(__first[2], __first[3]); _Tp __v3 = __binary_op(__v1, __v2); __init = __binary_op(__init, __v3); __first += 4; } } for (; __first != __last; ++__first) __init = __binary_op(__init, *__first); return __init; } # 292 "/usr/include/c++/10/numeric" 3 template constexpr inline _Tp reduce(_InputIterator __first, _InputIterator __last, _Tp __init) { return std::reduce(__first, __last, std::move(__init), plus<>()); } # 309 "/usr/include/c++/10/numeric" 3 template constexpr inline typename iterator_traits<_InputIterator>::value_type reduce(_InputIterator __first, _InputIterator __last) { using value_type = typename iterator_traits<_InputIterator>::value_type; return std::reduce(__first, __last, value_type{}, plus<>()); } # 336 "/usr/include/c++/10/numeric" 3 template constexpr _Tp transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2) { if constexpr (__and_v<__is_random_access_iter<_InputIterator1>, __is_random_access_iter<_InputIterator2>>) { while ((__last1 - __first1) >= 4) { _Tp __v1 = __binary_op1(__binary_op2(__first1[0], __first2[0]), __binary_op2(__first1[1], __first2[1])); _Tp __v2 = __binary_op1(__binary_op2(__first1[2], __first2[2]), __binary_op2(__first1[3], __first2[3])); _Tp __v3 = __binary_op1(__v1, __v2); __init = __binary_op1(__init, __v3); __first1 += 4; __first2 += 4; } } for (; __first1 != __last1; ++__first1, (void) ++__first2) __init = __binary_op1(__init, __binary_op2(*__first1, *__first2)); return __init; } # 380 "/usr/include/c++/10/numeric" 3 template constexpr inline _Tp transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) { return std::transform_reduce(__first1, __last1, __first2, std::move(__init), plus<>(), multiplies<>()); } # 405 "/usr/include/c++/10/numeric" 3 template constexpr _Tp transform_reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op) { if constexpr (__is_random_access_iter<_InputIterator>::value) { while ((__last - __first) >= 4) { _Tp __v1 = __binary_op(__unary_op(__first[0]), __unary_op(__first[1])); _Tp __v2 = __binary_op(__unary_op(__first[2]), __unary_op(__first[3])); _Tp __v3 = __binary_op(__v1, __v2); __init = __binary_op(__init, __v3); __first += 4; } } for (; __first != __last; ++__first) __init = __binary_op(__init, __unary_op(*__first)); return __init; } # 448 "/usr/include/c++/10/numeric" 3 template constexpr _OutputIterator exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOperation __binary_op) { while (__first != __last) { auto __v = __init; __init = __binary_op(__init, *__first); ++__first; *__result++ = std::move(__v); } return __result; } # 483 "/usr/include/c++/10/numeric" 3 template constexpr inline _OutputIterator exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init) { return std::exclusive_scan(__first, __last, __result, std::move(__init), plus<>()); } # 511 "/usr/include/c++/10/numeric" 3 template constexpr _OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op, _Tp __init) { for (; __first != __last; ++__first) *__result++ = __init = __binary_op(__init, *__first); return __result; } # 540 "/usr/include/c++/10/numeric" 3 template constexpr _OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op) { if (__first != __last) { auto __init = *__first; *__result++ = __init; ++__first; if (__first != __last) __result = std::inclusive_scan(__first, __last, __result, __binary_op, std::move(__init)); } return __result; } # 574 "/usr/include/c++/10/numeric" 3 template constexpr inline _OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result) { return std::inclusive_scan(__first, __last, __result, plus<>()); } # 601 "/usr/include/c++/10/numeric" 3 template constexpr _OutputIterator transform_exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op) { while (__first != __last) { auto __v = __init; __init = __binary_op(__init, __unary_op(*__first)); ++__first; *__result++ = std::move(__v); } return __result; } # 640 "/usr/include/c++/10/numeric" 3 template constexpr _OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _Tp __init) { for (; __first != __last; ++__first) *__result++ = __init = __binary_op(__init, __unary_op(*__first)); return __result; } # 674 "/usr/include/c++/10/numeric" 3 template constexpr _OutputIterator transform_inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op) { if (__first != __last) { auto __init = __unary_op(*__first); *__result++ = __init; ++__first; if (__first != __last) __result = std::transform_inclusive_scan(__first, __last, __result, __binary_op, __unary_op, std::move(__init)); } return __result; } } # 1 "/usr/include/c++/10/pstl/glue_numeric_defs.h" 1 3 # 15 "/usr/include/c++/10/pstl/glue_numeric_defs.h" 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::value_type> reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Tp __init); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _Tp __init); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, _BinaryOperation op); template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first); } # 708 "/usr/include/c++/10/numeric" 2 3 # 17 "/usr/include/c++/10/pstl/parallel_backend_serial.h" 2 3 namespace __pstl { namespace __serial { template class __buffer { std::allocator<_Tp> __allocator_; _Tp* __ptr_; const std::size_t __buf_size_; __buffer(const __buffer&) = delete; void operator=(const __buffer&) = delete; public: __buffer(std::size_t __n) : __allocator_(), __ptr_(__allocator_.allocate(__n)), __buf_size_(__n) {} operator bool() const { return __ptr_ != nullptr; } _Tp* get() const { return __ptr_; } ~__buffer() { __allocator_.deallocate(__ptr_, __buf_size_); } }; inline void __cancel_execution() { } template void __parallel_for(_ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f) { __f(__first, __last); } template _Value __parallel_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, const _Value& __identity, const _RealBody& __real_body, const _Reduction&) { if (__first == __last) { return __identity; } else { return __real_body(__first, __last, __identity); } } template _Tp __parallel_transform_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, _UnaryOp, _Tp __init, _BinaryOp, _Reduce __reduce) { return __reduce(__first, __last, __init); } template void __parallel_strict_scan(_ExecutionPolicy&&, _Index __n, _Tp __initial, _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex) { _Tp __sum = __initial; if (__n) __sum = __combine(__sum, __reduce(_Index(0), __n)); __apex(__sum); if (__n) __scan(_Index(0), __n, __initial); } template _Tp __parallel_transform_scan(_ExecutionPolicy&&, _Index __n, _UnaryOp, _Tp __init, _BinaryOp, _Reduce, _Scan __scan) { return __scan(_Index(0), __n, __init); } template void __parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _LeafSort __leaf_sort, std::size_t = 0) { __leaf_sort(__first, __last, __comp); } template void __parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _RandomAccessIterator3 __out, _Compare __comp, _LeafMerge __leaf_merge) { __leaf_merge(__first1, __last1, __first2, __last2, __out, __comp); } template void __parallel_invoke(_ExecutionPolicy&&, _F1&& __f1, _F2&& __f2) { std::forward<_F1>(__f1)(); std::forward<_F2>(__f2)(); } } } namespace __pstl { namespace __par_backend { using namespace __pstl::__serial; } } # 15 "/usr/include/c++/10/pstl/parallel_backend.h" 2 3 # 23 "/usr/include/c++/10/pstl/algorithm_impl.h" 2 3 # 1 "/usr/include/c++/10/pstl/parallel_impl.h" 1 3 # 17 "/usr/include/c++/10/pstl/parallel_impl.h" 3 namespace __pstl { namespace __internal { template _Index __parallel_find(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first) { typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType; const _DifferenceType __n = __last - __first; _DifferenceType __initial_dist = __b_first ? __n : -1; std::atomic<_DifferenceType> __extremum(__initial_dist); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__comp, __f, __first, &__extremum](_Index __i, _Index __j) { if (__comp(__i - __first, __extremum)) { _Index __res = __f(__i, __j); if (__res != __j) { const _DifferenceType __k = __res - __first; for (_DifferenceType __old = __extremum; __comp(__k, __old); __old = __extremum) { __extremum.compare_exchange_weak(__old, __k); } } } }); return __extremum != __initial_dist ? __first + __extremum : __last; } template bool __parallel_or(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f) { std::atomic __found(false); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__f, &__found](_Index __i, _Index __j) { if (!__found.load(std::memory_order_relaxed) && __f(__i, __j)) { __found.store(true, std::memory_order_relaxed); __par_backend::__cancel_execution(); } }); return __found; } } } # 24 "/usr/include/c++/10/pstl/algorithm_impl.h" 2 3 namespace __pstl { namespace __internal { template bool __brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, std::false_type) noexcept { return std::any_of(__first, __last, __pred); }; template bool __brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred, std::true_type) noexcept { return __unseq_backend::__simd_or(__first, __last - __first, __pred); }; template bool __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_any_of(__first, __last, __pred, __is_vector); } template bool __pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred, _IsVector __is_vector, std::true_type) { return __internal::__except_handler([&]() { return __internal::__parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { return __internal::__brick_any_of(__i, __j, __pred, __is_vector); }); }); } template _ForwardIterator __for_each_n_it_serial(_ForwardIterator __first, _Size __n, _Function __f) { for (; __n > 0; ++__first, --__n) __f(__first); return __first; } template void __brick_walk1(_ForwardIterator __first, _ForwardIterator __last, _Function __f, std::false_type) noexcept { std::for_each(__first, __last, __f); } template void __brick_walk1(_RandomAccessIterator __first, _RandomAccessIterator __last, _Function __f, std::true_type) noexcept { __unseq_backend::__simd_walk_1(__first, __last - __first, __f); } template void __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f, _IsVector __is_vector, std::false_type) noexcept { __internal::__brick_walk1(__first, __last, __f, __is_vector); } template void __pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f, _IsVector __is_vector, std::true_type) { __internal::__except_handler([&]() { __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { __internal::__brick_walk1(__i, __j, __f, __is_vector); }); }); } template void __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, std::false_type) noexcept { __brick(__first, __last); } template void __pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick, std::true_type) { __internal::__except_handler([&]() { __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); }); }); } template _ForwardIterator __brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, std::false_type) { return __internal::__for_each_n_it_serial(__first, __n, [&__f](_ForwardIterator __it) { __f(*__it); }); } template _RandomAccessIterator __brick_walk1_n(_RandomAccessIterator __first, _DifferenceType __n, _Function __f, std::true_type) noexcept { return __unseq_backend::__simd_walk_1(__first, __n, __f); } template _ForwardIterator __pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_walk1_n(__first, __n, __f, __is_vector); } template _RandomAccessIterator __pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f, _IsVector __is_vector, std::true_type) { __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector, std::true_type()); return __first + __n; } template _ForwardIterator __pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick, std::false_type) noexcept { return __brick(__first, __n); } template _RandomAccessIterator __pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick, std::true_type) { return __internal::__except_handler([&]() { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, [__brick](_RandomAccessIterator __i, _RandomAccessIterator __j) { __brick(__i, __j - __i); }); return __first + __n; }); } template _ForwardIterator2 __brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, std::false_type) noexcept { for (; __first1 != __last1; ++__first1, ++__first2) __f(*__first1, *__first2); return __first2; } template _ForwardIterator2 __brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, std::true_type) noexcept { return __unseq_backend::__simd_walk_2(__first1, __last1 - __first1, __first2, __f); } template _ForwardIterator2 __brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, std::false_type) noexcept { for (; __n > 0; --__n, ++__first1, ++__first2) __f(*__first1, *__first2); return __first2; } template _ForwardIterator2 __brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, std::true_type) noexcept { return __unseq_backend::__simd_walk_2(__first1, __n, __first2, __f); } template _ForwardIterator2 __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_walk2(__first1, __last1, __first2, __f, __is_vector); } template _ForwardIterator2 __pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, std::true_type) { return __internal::__except_handler([&]() { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__f, __first1, __first2, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { __internal::__brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector); }); return __first2 + (__last1 - __first1); }); } template _ForwardIterator2 __pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_walk2_n(__first1, __n, __first2, __f, __is_vector); } template _RandomAccessIterator2 __pattern_walk2_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n, _RandomAccessIterator2 __first2, _Function __f, _IsVector __is_vector, std::true_type) { return __internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, __first2, __f, __is_vector, std::true_type()); } template _ForwardIterator2 __pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Brick __brick, std::false_type) noexcept { return __brick(__first1, __last1, __first2); } template _RandomAccessIterator2 __pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _Brick __brick, std::true_type) { return __internal::__except_handler([&]() { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { __brick(__i, __j, __first2 + (__i - __first1)); }); return __first2 + (__last1 - __first1); }); } template _RandomAccessIterator2 __pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n, _RandomAccessIterator2 __first2, _Brick __brick, std::true_type) { return __internal::__except_handler([&]() { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { __brick(__i, __j - __i, __first2 + (__i - __first1)); }); return __first2 + __n; }); } template _ForwardIterator2 __pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Brick __brick, std::false_type) noexcept { return __brick(__first1, __n, __first2); } template _ForwardIterator3 __brick_walk3(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator3 __first3, _Function __f, std::false_type) noexcept { for (; __first1 != __last1; ++__first1, ++__first2, ++__first3) __f(*__first1, *__first2, *__first3); return __first3; } template _RandomAccessIterator3 __brick_walk3(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, std::true_type) noexcept { return __unseq_backend::__simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f); } template _ForwardIterator3 __pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector); } template _RandomAccessIterator3 __pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector, std::true_type) { return __internal::__except_handler([&]() { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__f, __first1, __first2, __first3, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { __internal::__brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f, __is_vector); }); return __first3 + (__last1 - __first1); }); } template bool __brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __p, std::false_type) noexcept { return std::equal(__first1, __last1, __first2, __last2, __p); } template bool __brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __p, std::true_type) noexcept { if (__last1 - __first1 != __last2 - __first2) return false; return __unseq_backend::__simd_first(__first1, __last1 - __first1, __first2, __internal::__not_pred<_BinaryPredicate>(__p)) .first == __last1; } template bool __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __p, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_equal(__first1, __last1, __first2, __last2, __p, __is_vector); } template bool __pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __p, _IsVector __is_vector, std::true_type) { if (__last1 - __first1 != __last2 - __first2) return false; return __internal::__except_handler([&]() { return !__internal::__parallel_or( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__first1, __first2, __p, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { return !__internal::__brick_equal(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), __p, __is_vector); }); }); } template bool __brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p, std::false_type) noexcept { return std::equal(__first1, __last1, __first2, __p); } template bool __brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _BinaryPredicate __p, std::true_type) noexcept { return __unseq_backend::__simd_first(__first1, __last1 - __first1, __first2, __not_pred<_BinaryPredicate>(__p)) .first == __last1; } template bool __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_equal(__first1, __last1, __first2, __p, __is_vector); } template bool __pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector, std::true_type) { return __internal::__except_handler([&]() { return !__internal::__parallel_or( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__first1, __first2, __p, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { return !__internal::__brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector); }); }); } template _ForwardIterator __brick_find_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, std::false_type) noexcept { return std::find_if(__first, __last, __pred); } template _RandomAccessIterator __brick_find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred, std::true_type) noexcept { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType; return __unseq_backend::__simd_first( __first, _SizeType(0), __last - __first, [&__pred](_RandomAccessIterator __it, _SizeType __i) { return __pred(__it[__i]); }); } template _ForwardIterator __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_find_if(__first, __last, __pred, __is_vector); } template _ForwardIterator __pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, _IsVector __is_vector, std::true_type) { return __internal::__except_handler([&]() { return __internal::__parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { return __internal::__brick_find_if(__i, __j, __pred, __is_vector); }, std::less::difference_type>(), true); }); } # 541 "/usr/include/c++/10/pstl/algorithm_impl.h" 3 template _RandomAccessIterator1 __find_subrange(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator1 __global_last, _RandomAccessIterator2 __s_first, _RandomAccessIterator2 __s_last, _BinaryPredicate __pred, bool __b_first, _IsVector __is_vector) noexcept { typedef typename std::iterator_traits<_RandomAccessIterator2>::value_type _ValueType; auto __n2 = __s_last - __s_first; if (__n2 < 1) { return __b_first ? __first : __last; } auto __n1 = __global_last - __first; if (__n1 < __n2) { return __last; } auto __cur = __last; while (__first != __last && (__global_last - __first >= __n2)) { __first = __internal::__brick_find_if( __first, __last, __equal_value_by_pred<_ValueType, _BinaryPredicate>(*__s_first, __pred), __is_vector); if (__first != __last && (__global_last - __first >= __n2) && __internal::__brick_equal(__s_first + 1, __s_last, __first + 1, __pred, __is_vector)) { if (__b_first) { return __first; } else { __cur = __first; } } else if (__first == __last) { break; } else { } ++__first; } return __cur; } template _RandomAccessIterator __find_subrange(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __global_last, _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector) noexcept { if (__global_last - __first < __count || __count < 1) { return __last; } auto __n = __global_last - __first; auto __unary_pred = __equal_value_by_pred<_Tp, _BinaryPredicate>(__value, __pred); while (__first != __last && (__global_last - __first >= __count)) { __first = __internal::__brick_find_if(__first, __last, __unary_pred, __is_vector); if (__first != __last && (__global_last - __first >= __count) && !__internal::__brick_any_of(__first + 1, __first + __count, __not_pred(__unary_pred), __is_vector)) { return __first; } else if (__first == __last) { break; } else { ++__first; } } return __last; } template _ForwardIterator1 __brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, std::false_type) noexcept { return std::find_end(__first, __last, __s_first, __s_last, __pred); } template _ForwardIterator1 __brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, std::true_type) noexcept { return __find_subrange(__first, __last, __last, __s_first, __s_last, __pred, false, std::true_type()); } template _ForwardIterator1 __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector); } template _ForwardIterator1 __pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, std::true_type) noexcept { if (__last - __first == __s_last - __s_first) { const bool __res = __internal::__pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred, __is_vector, std::true_type()); return __res ? __first : __last; } else { return __internal::__except_handler([&]() { return __internal::__parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { return __internal::__find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, __is_vector); }, std::greater::difference_type>(), false); }); } } template _ForwardIterator1 __brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, std::false_type) noexcept { return std::find_first_of(__first, __last, __s_first, __s_last, __pred); } template _ForwardIterator1 __brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, std::true_type) noexcept { return __unseq_backend::__simd_find_first_of(__first, __last, __s_first, __s_last, __pred); } template _ForwardIterator1 __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector); } template _ForwardIterator1 __pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, std::true_type) noexcept { return __internal::__except_handler([&]() { return __internal::__parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { return __internal::__brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector); }, std::less::difference_type>(), true); }); } template _ForwardIterator1 __brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, std::false_type) noexcept { return std::search(__first, __last, __s_first, __s_last, __pred); } template _ForwardIterator1 __brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, std::true_type) noexcept { return __internal::__find_subrange(__first, __last, __last, __s_first, __s_last, __pred, true, std::true_type()); } template _ForwardIterator1 __pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector); } template _ForwardIterator1 __pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector, std::true_type) noexcept { if (__last - __first == __s_last - __s_first) { const bool __res = __internal::__pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred, __is_vector, std::true_type()); return __res ? __first : __last; } else { return __internal::__except_handler([&]() { return __internal::__parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { return __internal::__find_subrange(__i, __j, __last, __s_first, __s_last, __pred, true, __is_vector); }, std::less::difference_type>(), true); }); } } template _ForwardIterator __brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred, std::false_type) noexcept { return std::search_n(__first, __last, __count, __value, __pred); } template _ForwardIterator __brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred, std::true_type) noexcept { return __internal::__find_subrange(__first, __last, __last, __count, __value, __pred, std::true_type()); } template _ForwardIterator __pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_search_n(__first, __last, __count, __value, __pred, __is_vector); } template _RandomAccessIterator __pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector, std::true_type) noexcept { if (__last - __first == __count) { const bool __result = !__internal::__pattern_any_of( std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); }, __is_vector, std::true_type()); return __result ? __first : __last; } else { return __internal::__except_handler([&__exec, __first, __last, __count, &__value, __pred, __is_vector]() { return __internal::__parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__last, __count, &__value, __pred, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) { return __internal::__find_subrange(__i, __j, __last, __count, __value, __pred, __is_vector); }, std::less::difference_type>(), true); }); } } template _OutputIterator __brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, std::false_type) noexcept { return std::copy_n(__first, __n, __result); } template _OutputIterator __brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, std::true_type) noexcept { return __unseq_backend::__simd_assign( __first, __n, __result, [](_ForwardIterator __first, _OutputIterator __result) { *__result = *__first; }); } template _OutputIterator __brick_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::false_type) noexcept { return std::copy(__first, __last, __result); } template _OutputIterator __brick_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, std::true_type) noexcept { return __unseq_backend::__simd_assign( __first, __last - __first, __result, [](_RandomAccessIterator __first, _OutputIterator __result) { *__result = *__first; }); } template _OutputIterator __brick_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::false_type) noexcept { return std::move(__first, __last, __result); } template _OutputIterator __brick_move(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, std::true_type) noexcept { return __unseq_backend::__simd_assign( __first, __last - __first, __result, [](_RandomAccessIterator __first, _OutputIterator __result) { *__result = std::move(*__first); }); } template _OutputIterator __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::false_type) noexcept { return std::swap_ranges(__first, __last, __result); } template _OutputIterator __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::true_type) noexcept { using std::iter_swap; return __unseq_backend::__simd_assign(__first, __last - __first, __result, iter_swap<_ForwardIterator, _OutputIterator>); } template _OutputIterator __brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, std::false_type) noexcept { return std::copy_if(__first, __last, __result, __pred); } template _OutputIterator __brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, std::true_type) noexcept { return std::copy_if(__first, __last, __result, __pred); } template std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(_ForwardIterator __first, _ForwardIterator __last, bool* __restrict __mask, _UnaryPredicate __pred, std::false_type) noexcept { auto __count_true = _DifferenceType(0); auto __size = __last - __first; static_assert(__is_random_access_iterator<_ForwardIterator>::value, "Pattern-brick error. Should be a random access iterator."); for (; __first != __last; ++__first, ++__mask) { *__mask = __pred(*__first); if (*__mask) { ++__count_true; } } return std::make_pair(__count_true, __size - __count_true); } template std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __mask, _UnaryPredicate __pred, std::true_type) noexcept { auto __result = __unseq_backend::__simd_calc_mask_1(__first, __last - __first, __mask, __pred); return std::make_pair(__result, (__last - __first) - __result); } template void __brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask, _Assigner __assigner, std::false_type) noexcept { for (; __first != __last; ++__first, ++__mask) { if (*__mask) { __assigner(__first, __result); ++__result; } } } template void __brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __restrict __mask, _Assigner __assigner, std::true_type) noexcept { __internal::__brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type()); } template void __brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, bool* __mask, std::false_type) noexcept { for (; __first != __last; ++__first, ++__mask) { if (*__mask) { *__out_true = *__first; ++__out_true; } else { *__out_false = *__first; ++__out_false; } } } template void __brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, bool* __mask, std::true_type) noexcept { __internal::__brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type()); } template _OutputIterator __pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_copy_if(__first, __last, __result, __pred, __is_vector); } template _OutputIterator __pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; const _DifferenceType __n = __last - __first; if (_DifferenceType(1) < __n) { __par_backend::__buffer __mask_buf(__n); return __internal::__except_handler([&__exec, __n, __first, __result, __is_vector, __pred, &__mask_buf]() { bool* __mask = __mask_buf.get(); _DifferenceType __m{}; __par_backend::__parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), [=](_DifferenceType __i, _DifferenceType __len) { return __internal::__brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, __pred, __is_vector) .first; }, std::plus<_DifferenceType>(), [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { __internal::__brick_copy_by_mask( __first + __i, __first + (__i + __len), __result + __initial, __mask + __i, [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, __is_vector); }, [&__m](_DifferenceType __total) { __m = __total; }); return __result + __m; }); } return __internal::__brick_copy_if(__first, __last, __result, __pred, __is_vector); } template typename std::iterator_traits<_ForwardIterator>::difference_type __brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, std::true_type) noexcept { return __unseq_backend::__simd_count(__first, __last - __first, __pred); } template typename std::iterator_traits<_ForwardIterator>::difference_type __brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, std::false_type) noexcept { return std::count_if(__first, __last, __pred); } template typename std::iterator_traits<_ForwardIterator>::difference_type __pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, std::false_type, _IsVector __is_vector) noexcept { return __internal::__brick_count(__first, __last, __pred, __is_vector); } template typename std::iterator_traits<_ForwardIterator>::difference_type __pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, std::true_type, _IsVector __is_vector) { typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType; return __internal::__except_handler([&]() { return __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, _SizeType(0), [__pred, __is_vector](_ForwardIterator __begin, _ForwardIterator __end, _SizeType __value) -> _SizeType { return __value + __internal::__brick_count(__begin, __end, __pred, __is_vector); }, std::plus<_SizeType>()); }); } template _ForwardIterator __brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, std::false_type) noexcept { return std::unique(__first, __last, __pred); } template _ForwardIterator __brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, std::true_type) noexcept { ; return std::unique(__first, __last, __pred); } template _ForwardIterator __pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_unique(__first, __last, __pred, __is_vector); } template _ForwardIterator __remove_elements(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _CalcMask __calc_mask, _IsVector __is_vector) { typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType; typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp; _DifferenceType __n = __last - __first; __par_backend::__buffer __mask_buf(__n); return __internal::__except_handler([&]() { bool* __mask = __mask_buf.get(); _DifferenceType __min = __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), _DifferenceType(0), __n, __n, [__first, __mask, &__calc_mask, __is_vector](_DifferenceType __i, _DifferenceType __j, _DifferenceType __local_min) -> _DifferenceType { __calc_mask(__mask + __i, __mask + __j, __first + __i); if (__local_min < __i) { return __local_min; } bool* __result = __internal::__brick_find_if(__mask + __i, __mask + __j, [](bool __val) { return !__val; }, __is_vector); if (__result - __mask == __j) { return __local_min; } return std::min(__local_min, _DifferenceType(__result - __mask)); }, [](_DifferenceType __local_min1, _DifferenceType __local_min2) -> _DifferenceType { return std::min(__local_min1, __local_min2); }); if (__min == __n) { return __last; } __n -= __min; __first += __min; __par_backend::__buffer<_Tp> __buf(__n); _Tp* __result = __buf.get(); __mask += __min; _DifferenceType __m{}; __par_backend::__parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), [__mask, __is_vector](_DifferenceType __i, _DifferenceType __len) { return __internal::__brick_count(__mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, __is_vector); }, std::plus<_DifferenceType>(), [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { __internal::__brick_copy_by_mask( __first + __i, __first + __i + __len, __result + __initial, __mask + __i, [](_ForwardIterator __x, _Tp* __z) { __internal::__invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); }, [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); }); }, __is_vector); }, [&__m](_DifferenceType __total) { __m = __total; }); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m, [__result, __first, __is_vector](_Tp* __i, _Tp* __j) { __internal::__brick_move(__i, __j, __first + (__i - __result), __is_vector); }); return __first + __m; }); } template _ForwardIterator __pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, _IsVector __is_vector, std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; if (__first == __last) { return __last; } if (__first + 1 == __last || __first + 2 == __last) { return __internal::__brick_unique(__first, __last, __pred, __is_vector); } return __internal::__remove_elements( std::forward<_ExecutionPolicy>(__exec), ++__first, __last, [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) { __internal::__brick_walk3( __b, __e, __it - 1, __it, [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); }, __is_vector); }, __is_vector); } template OutputIterator __brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred, std::false_type) noexcept { return std::unique_copy(__first, __last, __result, __pred); } template OutputIterator __brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result, _BinaryPredicate __pred, std::true_type) noexcept { return std::unique_copy(__first, __last, __result, __pred); } template _OutputIterator __pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_unique_copy(__first, __last, __result, __pred, __is_vector); } template _DifferenceType __brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, _BinaryPredicate __pred, std::false_type) noexcept { _DifferenceType __count = 0; for (; __first != __last; ++__first, ++__mask) { *__mask = !__pred(*__first, *(__first - 1)); __count += *__mask; } return __count; } template _DifferenceType __brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask, _BinaryPredicate __pred, std::true_type) noexcept { return __unseq_backend::__simd_calc_mask_2(__first, __last - __first, __mask, __pred); } template _OutputIterator __pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; const _DifferenceType __n = __last - __first; if (_DifferenceType(2) < __n) { __par_backend::__buffer __mask_buf(__n); if (_DifferenceType(2) < __n) { return __internal::__except_handler([&__exec, __n, __first, __result, __pred, __is_vector, &__mask_buf]() { bool* __mask = __mask_buf.get(); _DifferenceType __m{}; __par_backend::__parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0), [=](_DifferenceType __i, _DifferenceType __len) -> _DifferenceType { _DifferenceType __extra = 0; if (__i == 0) { __mask[__i] = true; if (--__len == 0) return 1; ++__i; ++__extra; } return __internal::__brick_calc_mask_2<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, __pred, __is_vector) + __extra; }, std::plus<_DifferenceType>(), [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { __internal::__brick_copy_by_mask( __first + __i, __first + (__i + __len), __result + __initial, __mask + __i, [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, __is_vector); }, [&__m](_DifferenceType __total) { __m = __total; }); return __result + __m; }); } } return __internal::__brick_unique_copy(__first, __last, __result, __pred, __is_vector); } template void __brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, std::false_type) noexcept { std::reverse(__first, __last); } template void __brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, std::true_type) noexcept { typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType; const auto __n = (__last - __first) / 2; __unseq_backend::__simd_walk_2(__first, __n, std::reverse_iterator<_BidirectionalIterator>(__last), [](_ReferenceType __x, _ReferenceType __y) { using std::swap; swap(__x, __y); }); } template void __brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, std::false_type) noexcept { for (--__d_last; __first != __last; ++__first, --__d_last) { using std::iter_swap; iter_swap(__first, __d_last); } } template void __brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last, std::true_type) noexcept { typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType; __unseq_backend::__simd_walk_2(__first, __last - __first, std::reverse_iterator<_BidirectionalIterator>(__d_last), [](_ReferenceType __x, _ReferenceType __y) { using std::swap; swap(__x, __y); }); } template void __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, _IsVector _is_vector, std::false_type) noexcept { __internal::__brick_reverse(__first, __last, _is_vector); } template void __pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _IsVector __is_vector, std::true_type) { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2, [__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) { __internal::__brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector); }); } template _OutputIterator __brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, std::false_type) noexcept { return std::reverse_copy(__first, __last, __d_first); } template _OutputIterator __brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, std::true_type) noexcept { typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType1; typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2; return __unseq_backend::__simd_walk_2(std::reverse_iterator<_BidirectionalIterator>(__last), __last - __first, __d_first, [](_ReferenceType1 __x, _ReferenceType2 __y) { __y = __x; }); } template _OutputIterator __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_reverse_copy(__first, __last, __d_first, __is_vector); } template _OutputIterator __pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first, _IsVector __is_vector, std::true_type) { auto __len = __last - __first; __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) { __internal::__brick_reverse_copy(__inner_first, __inner_last, __d_first + (__len - (__inner_last - __first)), __is_vector); }); return __d_first + __len; } template _ForwardIterator __brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, std::false_type) noexcept { return std::rotate(__first, __middle, __last); } template _ForwardIterator __brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, std::true_type) noexcept { auto __n = __last - __first; auto __m = __middle - __first; const _ForwardIterator __ret = __first + (__last - __middle); bool __is_left = (__m <= __n / 2); if (!__is_left) __m = __n - __m; while (__n > 1 && __m > 0) { using std::iter_swap; const auto __m_2 = __m * 2; if (__is_left) { for (; __last - __first >= __m_2; __first += __m) { __unseq_backend::__simd_assign(__first, __m, __first + __m, iter_swap<_ForwardIterator, _ForwardIterator>); } } else { for (; __last - __first >= __m_2; __last -= __m) { __unseq_backend::__simd_assign(__last - __m, __m, __last - __m_2, iter_swap<_ForwardIterator, _ForwardIterator>); } } __is_left = !__is_left; __m = __n % __m; __n = __last - __first; } return __ret; } template _ForwardIterator __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_rotate(__first, __middle, __last, __is_vector); } template _ForwardIterator __pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp; auto __n = __last - __first; auto __m = __middle - __first; if (__m <= __n / 2) { __par_backend::__buffer<_Tp> __buf(__n - __m); return __internal::__except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() { _Tp* __result = __buf.get(); __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __middle, __last, [__middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { __internal::__brick_uninitialized_move(__b, __e, __result + (__b - __middle), __is_vector); }); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle, [__last, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { __internal::__brick_move(__b, __e, __b + (__last - __middle), __is_vector); }); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + (__n - __m), [__first, __result, __is_vector](_Tp* __b, _Tp* __e) { __internal::__brick_move(__b, __e, __first + (__b - __result), __is_vector); }); return __first + (__last - __middle); }); } else { __par_backend::__buffer<_Tp> __buf(__m); return __internal::__except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() { _Tp* __result = __buf.get(); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle, [__first, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { __internal::__brick_uninitialized_move( __b, __e, __result + (__b - __first), __is_vector); }); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last, [__first, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { __internal::__brick_move(__b, __e, __first + (__b - __middle), __is_vector); }); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m, [__n, __m, __first, __result, __is_vector](_Tp* __b, _Tp* __e) { __internal::__brick_move( __b, __e, __first + ((__n - __m) + (__b - __result)), __is_vector); }); return __first + (__last - __middle); }); } } template _OutputIterator __brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result, std::false_type) noexcept { return std::rotate_copy(__first, __middle, __last, __result); } template _OutputIterator __brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result, std::true_type) noexcept { _OutputIterator __res = __internal::__brick_copy(__middle, __last, __result, std::true_type()); return __internal::__brick_copy(__first, __middle, __res, std::true_type()); } template _OutputIterator __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_rotate_copy(__first, __middle, __last, __result, __is_vector); } template _OutputIterator __pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector, std::true_type) { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__first, __last, __middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) { if (__b > __middle) { __internal::__brick_copy(__b, __e, __result + (__b - __middle), __is_vector); } else { _OutputIterator __new_result = __result + ((__last - __middle) + (__b - __first)); if (__e < __middle) { __internal::__brick_copy(__b, __e, __new_result, __is_vector); } else { __internal::__brick_copy(__b, __middle, __new_result, __is_vector); __internal::__brick_copy(__middle, __e, __result, __is_vector); } } }); return __result + (__last - __first); } template bool __brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, std::false_type) noexcept { return std::is_partitioned(__first, __last, __pred); } template bool __brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType; if (__first == __last) { return true; } else { _ForwardIterator __result = __unseq_backend::__simd_first( __first, _SizeType(0), __last - __first, [&__pred](_ForwardIterator __it, _SizeType __i) { return !__pred(__it[__i]); }); if (__result == __last) { return true; } else { ++__result; return !__unseq_backend::__simd_or(__result, __last - __result, __pred); } } } template bool __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_is_partitioned(__first, __last, __pred, __is_vector); } template bool __pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::true_type) { if (__first == __last) { return true; } else { return __internal::__except_handler([&]() { enum _ReduceType { __not_init = -1, __broken, __all_true, __all_false, __true_false }; _ReduceType __init = __not_init; _ReduceType __table[] = {__broken, __broken, __broken, __broken, __broken, __all_true, __true_false, __true_false, __broken, __broken, __all_false, __broken, __broken, __broken, __true_false, __broken}; __init = __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, [&__pred, &__table, __is_vector](_ForwardIterator __i, _ForwardIterator __j, _ReduceType __value) -> _ReduceType { if (__value == __broken) { return __broken; } _ReduceType __res = __not_init; if (__pred(*__i)) { _ForwardIterator __x = __internal::__brick_find_if(__i + 1, __j, __not_pred<_UnaryPredicate>(__pred), __is_vector); if (__x != __j) { _ForwardIterator __y = __internal::__brick_find_if(__x + 1, __j, __pred, __is_vector); if (__y != __j) { return __broken; } else { __res = __true_false; } } else { __res = __all_true; } } else { if (__internal::__brick_find_if(__i + 1, __j, __pred, __is_vector) != __j) { return __broken; } else { __res = __all_false; } } return (__value == -1) ? __res : __table[__value * 4 + __res]; }, [&__table](_ReduceType __val1, _ReduceType __val2) -> _ReduceType { if (__val1 == __broken || __val2 == __broken) { return __broken; } return __table[__val1 * 4 + __val2]; }); return __init != __broken; }); } } template _ForwardIterator __brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, std::false_type) noexcept { return std::partition(__first, __last, __pred); } template _ForwardIterator __brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, std::true_type) noexcept { ; return std::partition(__first, __last, __pred); } template _ForwardIterator __pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_partition(__first, __last, __pred, __is_vector); } template _ForwardIterator __pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::true_type) { struct _PartitionRange { _ForwardIterator __begin; _ForwardIterator __pivot; _ForwardIterator __end; }; return __internal::__except_handler([&]() { _PartitionRange __init{__last, __last, __last}; auto __reductor = [&__exec, __is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange { auto __size1 = __val1.__end - __val1.__pivot; auto __size2 = __val2.__pivot - __val2.__begin; auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin); if (__val1.__end == __val1.__pivot) { return {__new_begin, __val2.__pivot, __val2.__end}; } else if (__size2 > __size1) { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size1, [__val1, __val2, __size1, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { __internal::__brick_swap_ranges(__i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), __is_vector); }); return {__new_begin, __val2.__pivot - __size1, __val2.__end}; } else { __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size2, [__val1, __val2, __is_vector](_ForwardIterator __i, _ForwardIterator __j) { __internal::__brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), __is_vector); }); return {__new_begin, __val1.__pivot + __size2, __val2.__end}; } }; _PartitionRange __result = __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, [__pred, __is_vector, __reductor](_ForwardIterator __i, _ForwardIterator __j, _PartitionRange __value) -> _PartitionRange { _ForwardIterator __pivot = __internal::__brick_partition(__i, __j, __pred, __is_vector); return __reductor(__value, {__i, __pivot, __j}); }, __reductor); return __result.__pivot; }); } template _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, std::false_type) noexcept { return std::stable_partition(__first, __last, __pred); } template _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, std::true_type) noexcept { ; return std::stable_partition(__first, __last, __pred); } template _BidirectionalIterator __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_stable_partition(__first, __last, __pred, __is_vector); } template _BidirectionalIterator __pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::true_type) noexcept { struct _PartitionRange { _BidirectionalIterator __begin; _BidirectionalIterator __pivot; _BidirectionalIterator __end; }; return __internal::__except_handler([&]() { _PartitionRange __init{__last, __last, __last}; auto __reductor = [__is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange { auto __size1 = __val1.__end - __val1.__pivot; auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin); if (__val1.__end == __val1.__pivot) { return {__new_begin, __val2.__pivot, __val2.__end}; } else { __internal::__brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, __is_vector); return {__new_begin, __val2.__pivot - __size1, __val2.__end}; } }; _PartitionRange __result = __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, [&__pred, __is_vector, __reductor](_BidirectionalIterator __i, _BidirectionalIterator __j, _PartitionRange __value) -> _PartitionRange { _BidirectionalIterator __pivot = __internal::__brick_stable_partition(__i, __j, __pred, __is_vector); return __reductor(__value, {__i, __pivot, __j}); }, __reductor); return __result.__pivot; }); } template std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, std::false_type) noexcept { return std::partition_copy(__first, __last, __out_true, __out_false, __pred); } template std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, std::true_type) noexcept { return std::partition_copy(__first, __last, __out_true, __out_false, __pred); } template std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); } template std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; typedef std::pair<_DifferenceType, _DifferenceType> _ReturnType; const _DifferenceType __n = __last - __first; if (_DifferenceType(1) < __n) { __par_backend::__buffer __mask_buf(__n); return __internal::__except_handler([&__exec, __n, __first, __out_true, __out_false, __is_vector, __pred, &__mask_buf]() { bool* __mask = __mask_buf.get(); _ReturnType __m{}; __par_backend::__parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, std::make_pair(_DifferenceType(0), _DifferenceType(0)), [=](_DifferenceType __i, _DifferenceType __len) { return __internal::__brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i, __pred, __is_vector); }, [](const _ReturnType& __x, const _ReturnType& __y) -> _ReturnType { return std::make_pair(__x.first + __y.first, __x.second + __y.second); }, [=](_DifferenceType __i, _DifferenceType __len, _ReturnType __initial) { __internal::__brick_partition_by_mask(__first + __i, __first + (__i + __len), __out_true + __initial.first, __out_false + __initial.second, __mask + __i, __is_vector); }, [&__m](_ReturnType __total) { __m = __total; }); return std::make_pair(__out_true + __m.first, __out_false + __m.second); }); } return __internal::__brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector); } template void __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _IsVector , std::false_type, _IsMoveConstructible) noexcept { std::sort(__first, __last, __comp); } template void __pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _IsVector , std::true_type, std::true_type) { __internal::__except_handler([&]() { __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, [](_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { std::sort(__first, __last, __comp); }, __last - __first); }); } template void __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _IsVector , std::false_type) noexcept { std::stable_sort(__first, __last, __comp); } template void __pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _IsVector , std::true_type) { __internal::__except_handler([&]() { __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, [](_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { std::stable_sort(__first, __last, __comp); }); }); } template void __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp, _IsVector, std::false_type) noexcept { std::partial_sort(__first, __middle, __last, __comp); } template void __pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp, _IsVector, std::true_type) { const auto __n = __middle - __first; __internal::__except_handler([&]() { __par_backend::__parallel_stable_sort( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, [__n](_RandomAccessIterator __begin, _RandomAccessIterator __end, _Compare __comp) { if (__n < __end - __begin) std::partial_sort(__begin, __begin + __n, __end, __comp); else std::sort(__begin, __end, __comp); }, __n); }); } template _RandomAccessIterator __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector, std::false_type) noexcept { return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp); } template _RandomAccessIterator __pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector __is_vector, std::true_type) { if (__last == __first || __d_last == __d_first) { return __d_first; } auto __n1 = __last - __first; auto __n2 = __d_last - __d_first; return __internal::__except_handler([&]() { if (__n2 >= __n1) { __par_backend::__parallel_stable_sort( std::forward<_ExecutionPolicy>(__exec), __d_first, __d_first + __n1, __comp, [__first, __d_first, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j, _Compare __comp) { _ForwardIterator __i1 = __first + (__i - __d_first); _ForwardIterator __j1 = __first + (__j - __d_first); __internal::__brick_copy(__i1, __j1, __i, __is_vector); std::sort(__i, __j, __comp); }, __n1); return __d_first + __n1; } else { typedef typename std::iterator_traits<_ForwardIterator>::value_type _T1; typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _T2; __par_backend::__buffer<_T1> __buf(__n1); _T1* __r = __buf.get(); __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n1, __comp, [__n2, __first, __r](_T1* __i, _T1* __j, _Compare __comp) { _ForwardIterator __it = __first + (__i - __r); for (_T1* __k = __i; __k != __j; ++__k, ++__it) { ::new (__k) _T2(*__it); } if (__n2 < __j - __i) std::partial_sort(__i, __i + __n2, __j, __comp); else std::sort(__i, __j, __comp); }, __n2); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2, [__r, __d_first, __is_vector](_T1* __i, _T1* __j) { __internal::__brick_move(__i, __j, __d_first + (__i - __r), __is_vector); }); return __d_first + __n2; } }); } template _ForwardIterator __brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, std::true_type, bool __or_semantic) noexcept { return __unseq_backend::__simd_adjacent_find(__first, __last, __pred, __or_semantic); } template _ForwardIterator __brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, std::false_type, bool __or_semantic) noexcept { return std::adjacent_find(__first, __last, __pred); } template _ForwardIterator __pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred, std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept { return __internal::__brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic); } template _RandomAccessIterator __pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _BinaryPredicate __pred, std::true_type, _IsVector __is_vector, bool __or_semantic) { if (__last - __first < 2) return __last; return __internal::__except_handler([&]() { return __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, __last, [__last, __pred, __is_vector, __or_semantic](_RandomAccessIterator __begin, _RandomAccessIterator __end, _RandomAccessIterator __value) -> _RandomAccessIterator { if (__or_semantic && __value < __last) { __par_backend::__cancel_execution(); return __value; } if (__value > __begin) { if (__end != __last) ++__end; const _RandomAccessIterator __res = __internal::__brick_adjacent_find(__begin, __end, __pred, __is_vector, __or_semantic); if (__res < __end) __value = __res; } return __value; }, [](_RandomAccessIterator __x, _RandomAccessIterator __y) -> _RandomAccessIterator { return __x < __y ? __x : __y; } ); }); } template void __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp, _IsVector, std::false_type) noexcept { std::nth_element(__first, __nth, __last, __comp); } template void __pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, std::true_type) noexcept { if (__first == __last || __nth == __last) { return; } using std::iter_swap; typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _Tp; _RandomAccessIterator __x; do { __x = __internal::__pattern_partition(std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, [&__comp, __first](const _Tp& __x) { return __comp(__x, *__first); }, __is_vector, std::true_type()); --__x; if (__x != __first) { iter_swap(__first, __x); } if (__x - __nth > 0) { __last = __x; } else if (__x - __nth < 0) { if (!__comp(*__nth, *__x) && !__comp(*__x, *__nth)) { ++__x; } else { iter_swap(__nth, __x); } __first = __x; } } while (__x != __nth); } template void __brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, std::true_type) noexcept { __unseq_backend::__simd_fill_n(__first, __last - __first, __value); } template void __brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, std::false_type) noexcept { std::fill(__first, __last, __value); } template void __pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, std::false_type, _IsVector __is_vector) noexcept { __internal::__brick_fill(__first, __last, __value, __is_vector); } template _ForwardIterator __pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, std::true_type, _IsVector __is_vector) { return __internal::__except_handler([&__exec, __first, __last, &__value, __is_vector]() { __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { __internal::__brick_fill(__begin, __end, __value, __is_vector); }); return __last; }); } template _OutputIterator __brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, std::true_type) noexcept { return __unseq_backend::__simd_fill_n(__first, __count, __value); } template _OutputIterator __brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, std::false_type) noexcept { return std::fill_n(__first, __count, __value); } template _OutputIterator __pattern_fill_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, const _Tp& __value, std::false_type, _IsVector __is_vector) noexcept { return __internal::__brick_fill_n(__first, __count, __value, __is_vector); } template _OutputIterator __pattern_fill_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, const _Tp& __value, std::true_type, _IsVector __is_vector) { return __internal::__pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __value, std::true_type(), __is_vector); } template void __brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g, std::true_type) noexcept { __unseq_backend::__simd_generate_n(__first, __last - __first, __g); } template void __brick_generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __g, std::false_type) noexcept { std::generate(__first, __last, __g); } template void __pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, std::false_type, _IsVector __is_vector) noexcept { __internal::__brick_generate(__first, __last, __g, __is_vector); } template _ForwardIterator __pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g, std::true_type, _IsVector __is_vector) { return __internal::__except_handler([&]() { __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) { __internal::__brick_generate(__begin, __end, __g, __is_vector); }); return __last; }); } template OutputIterator __brick_generate_n(OutputIterator __first, Size __count, _Generator __g, std::true_type) noexcept { return __unseq_backend::__simd_generate_n(__first, __count, __g); } template OutputIterator __brick_generate_n(OutputIterator __first, Size __count, _Generator __g, std::false_type) noexcept { return std::generate_n(__first, __count, __g); } template _OutputIterator __pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g, std::false_type, _IsVector __is_vector) noexcept { return __internal::__brick_generate_n(__first, __count, __g, __is_vector); } template _OutputIterator __pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g, std::true_type, _IsVector __is_vector) { static_assert(__is_random_access_iterator<_OutputIterator>::value, "Pattern-brick error. Should be a random access iterator."); return __internal::__pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g, std::true_type(), __is_vector); } template _ForwardIterator __brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, std::false_type) noexcept { return std::remove_if(__first, __last, __pred); } template _RandomAccessIterator __brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred, std::true_type) noexcept { return std::remove_if(__first, __last, __pred); } template _ForwardIterator __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_remove_if(__first, __last, __pred, __is_vector); } template _ForwardIterator __pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, _IsVector __is_vector, std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType; if (__first == __last || __first + 1 == __last) { return __internal::__brick_remove_if(__first, __last, __pred, __is_vector); } return __internal::__remove_elements( std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) { __internal::__brick_walk2(__b, __e, __it, [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, __is_vector); }, __is_vector); } template _OutputIterator __brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, std::false_type) noexcept { return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp); } template _OutputIterator __brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, std::true_type) noexcept { ; return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp); } template _OutputIterator __pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector); } template _OutputIterator __pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector, std::true_type) { __par_backend::__parallel_merge( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp, [__is_vector](_RandomAccessIterator1 __f1, _RandomAccessIterator1 __l1, _RandomAccessIterator2 __f2, _RandomAccessIterator2 __l2, _OutputIterator __f3, _Compare __comp) { return __internal::__brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); }); return __d_first + (__last1 - __first1) + (__last2 - __first2); } template void __brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp, std::false_type) noexcept { std::inplace_merge(__first, __middle, __last, __comp); } template void __brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp, std::true_type) noexcept { std::inplace_merge(__first, __middle, __last, __comp); } template void __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { __internal::__brick_inplace_merge(__first, __middle, __last, __comp, __is_vector); } template void __pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector, std::true_type) { if (__first == __last || __first == __middle || __middle == __last) { return; } typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _Tp; auto __n = __last - __first; __par_backend::__buffer<_Tp> __buf(__n); _Tp* __r = __buf.get(); __internal::__except_handler([&]() { auto __move_values = [](_BidirectionalIterator __x, _Tp* __z) { __internal::__invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); }, [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); }); }; auto __move_sequences = [](_BidirectionalIterator __first1, _BidirectionalIterator __last1, _Tp* __first2) { return __internal::__brick_uninitialized_move(__first1, __last1, __first2, _IsVector()); }; __par_backend::__parallel_merge( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __middle, __last, __r, __comp, [__n, __move_values, __move_sequences](_BidirectionalIterator __f1, _BidirectionalIterator __l1, _BidirectionalIterator __f2, _BidirectionalIterator __l2, _Tp* __f3, _Compare __comp) { auto __func = __par_backend::__serial_move_merge( __n, __move_values, __move_sequences); __func(__f1, __l1, __f2, __l2, __f3, __comp); return __f3 + (__l1 - __f1) + (__l2 - __f2); }); __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n, [__r, __first, __is_vector](_Tp* __i, _Tp* __j) { __internal::__brick_move(__i, __j, __first + (__i - __r), __is_vector); }); }); } template bool __pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector, std::false_type) noexcept { return std::includes(__first1, __last1, __first2, __last2, __comp); } template bool __pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector, std::true_type) { if (__first2 >= __last2) return true; if (__first1 >= __last1 || __comp(*__first2, *__first1) || __comp(*(__last1 - 1), *(__last2 - 1))) return false; __first1 = std::lower_bound(__first1, __last1, *__first2, __comp); if (__first1 == __last1) return false; if (__last2 - __first2 == 1) return !__comp(*__first1, *__first2) && !__comp(*__first2, *__first1); return __internal::__except_handler([&]() { return !__internal::__parallel_or( std::forward<_ExecutionPolicy>(__exec), __first2, __last2, [__first1, __last1, __first2, __last2, &__comp](_ForwardIterator2 __i, _ForwardIterator2 __j) { ; auto __is_equal = [&__comp](_ForwardIterator2 __a, _ForwardIterator2 __b) -> bool { return !__comp(*__a, *__b) && !__comp(*__b, *__a); }; if (__i > __first2 && __is_equal(__i, __i - 1)) { if (__is_equal(__i, __j - 1)) return false; __i = std::upper_bound(__i, __last2, *__i, __comp); } if (__j < __last2 && __is_equal(__j - 1, __j)) __j = std::upper_bound(__j, __last2, *__j, __comp); auto __b = std::lower_bound(__first1, __last1, *__i, __comp); ; ; return !std::includes(__b, __last1, __i, __j, __comp); }); }); } constexpr auto __set_algo_cut_off = 1000; template _OutputIterator __parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector) { typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; typedef typename std::iterator_traits<_OutputIterator>::value_type _T; struct _SetRange { _DifferenceType __pos, __len, __buf_pos; bool empty() const { return __len == 0; } }; const _DifferenceType __n1 = __last1 - __first1; const _DifferenceType __n2 = __last2 - __first2; __par_backend::__buffer<_T> __buf(__size_func(__n1, __n2)); return __internal::__except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector, __comp, __size_func, __set_op, &__buf]() { auto __buffer = __buf.get(); _DifferenceType __m{}; auto __scan = [=](_DifferenceType, _DifferenceType, const _SetRange& __s) { if (!__s.empty()) __internal::__brick_move(__buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos, __is_vector); }; __par_backend::__parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n1, _SetRange{0, 0, 0}, [=](_DifferenceType __i, _DifferenceType __len) { _ForwardIterator1 __b = __first1 + __i, __e = __first1 + (__i + __len); if (__b != __first1) __b = std::upper_bound(__b, __last1, *__b, __comp); if (__e != __last1) __e = std::upper_bound(__e, __last1, *__e, __comp); if (__e - __b < 1) { _ForwardIterator2 __bb = __last2; if (__b != __last1) __bb = std::lower_bound(__first2, __last2, *__b, __comp); const _DifferenceType __buf_pos = __size_func((__b - __first1), (__bb - __first2)); return _SetRange{0, 0, __buf_pos}; } _ForwardIterator2 __bb = __first2; if (__b != __first1) __bb = std::lower_bound(__first2, __last2, *__b, __comp); _ForwardIterator2 __ee = __last2; if (__e != __last1) __ee = std::lower_bound(__bb, __last2, *__e, __comp); const _DifferenceType __buf_pos = __size_func((__b - __first1), (__bb - __first2)); auto __buffer_b = __buffer + __buf_pos; auto __res = __set_op(__b, __e, __bb, __ee, __buffer_b, __comp); return _SetRange{0, __res - __buffer_b, __buf_pos}; }, [](const _SetRange& __a, const _SetRange& __b) { if (__b.__buf_pos > __a.__buf_pos || ((__b.__buf_pos == __a.__buf_pos) && !__b.empty())) return _SetRange{__a.__pos + __a.__len + __b.__pos, __b.__len, __b.__buf_pos}; return _SetRange{__b.__pos + __b.__len + __a.__pos, __a.__len, __a.__buf_pos}; }, __scan, [&__m, &__scan](const _SetRange& __total) { __scan(0, 0, __total); __m = __total.__pos + __total.__len; }); return __result + __m; }); } template _OutputIterator __parallel_set_union_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _SetUnionOp __set_union_op, _IsVector __is_vector) { typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; const auto __n1 = __last1 - __first1; const auto __n2 = __last2 - __first2; auto __copy_range1 = [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }; auto __copy_range2 = [__is_vector](_ForwardIterator2 __begin, _ForwardIterator2 __end, _OutputIterator __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }; if (__n2 == 0) return __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, __copy_range1, std::true_type()); if (__n1 == 0) return __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, __copy_range2, std::true_type()); _ForwardIterator1 __left_bound_seq_1 = std::lower_bound(__first1, __last1, *__first2, __comp); if (__left_bound_seq_1 == __last1) { __par_backend::__parallel_invoke( std::forward<_ExecutionPolicy>(__exec), [=] { __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, __copy_range1, std::true_type()); }, [=] { __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result + __n1, __copy_range2, std::true_type()); }); return __result + __n1 + __n2; } _ForwardIterator2 __left_bound_seq_2 = std::lower_bound(__first2, __last2, *__first1, __comp); if (__left_bound_seq_2 == __last2) { __par_backend::__parallel_invoke( std::forward<_ExecutionPolicy>(__exec), [=] { __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, __copy_range2, std::true_type()); }, [=] { __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result + __n2, __copy_range1, std::true_type()); }); return __result + __n1 + __n2; } const auto __m1 = __left_bound_seq_1 - __first1; if (__m1 > __set_algo_cut_off) { auto __res_or = __result; __result += __m1; __par_backend::__parallel_invoke( std::forward<_ExecutionPolicy>(__exec), [=] { __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or, __copy_range1, std::true_type()); }, [=, &__result] { __result = __internal::__parallel_set_op( std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2, __result, __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op, __is_vector); }); return __result; } const auto __m2 = __left_bound_seq_2 - __first2; ; if (__m2 > __set_algo_cut_off) { auto __res_or = __result; __result += __m2; __par_backend::__parallel_invoke( std::forward<_ExecutionPolicy>(__exec), [=] { __internal::__pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or, __copy_range2, std::true_type()); }, [=, &__result] { __result = __internal::__parallel_set_op( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __left_bound_seq_2, __last2, __result, __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op, __is_vector); }); return __result; } return __internal::__parallel_set_op( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op, __is_vector); } template _OutputIterator __brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::false_type) noexcept { return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::true_type) noexcept { ; return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); } template _OutputIterator __pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::true_type) { const auto __n1 = __last1 - __first1; const auto __n2 = __last2 - __first2; if (__n1 + __n2 <= __set_algo_cut_off) return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); typedef typename std::iterator_traits<_OutputIterator>::value_type _T; return __internal::__parallel_set_union_op( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _T* __result, _Compare __comp) { return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); }, __is_vector); } template _OutputIterator __brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::false_type) noexcept { return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::true_type) noexcept { ; return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); } template _OutputIterator __pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_OutputIterator>::value_type _T; typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; const auto __n1 = __last1 - __first1; const auto __n2 = __last2 - __first2; if (__n1 == 0 || __n2 == 0) return __result; _ForwardIterator1 __left_bound_seq_1 = std::lower_bound(__first1, __last1, *__first2, __comp); if (__left_bound_seq_1 == __last1) return __result; _ForwardIterator2 __left_bound_seq_2 = std::lower_bound(__first2, __last2, *__first1, __comp); if (__left_bound_seq_2 == __last2) return __result; const auto __m1 = __last1 - __left_bound_seq_1 + __n2; if (__m1 > __set_algo_cut_off) { return __internal::__parallel_set_op( std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2, __result, __comp, [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); }, [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _T* __result, _Compare __comp) { return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp); }, __is_vector); } const auto __m2 = __last2 - __left_bound_seq_2 + __n1; if (__m2 > __set_algo_cut_off) { __result = __internal::__parallel_set_op( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __left_bound_seq_2, __last2, __result, __comp, [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); }, [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _T* __result, _Compare __comp) { return std::set_intersection(__first2, __last2, __first1, __last1, __result, __comp); }, __is_vector); return __result; } return std::set_intersection(__left_bound_seq_1, __last1, __left_bound_seq_2, __last2, __result, __comp); } template _OutputIterator __brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::false_type) noexcept { return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::true_type) noexcept { ; return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); } template _OutputIterator __pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_OutputIterator>::value_type _T; typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; const auto __n1 = __last1 - __first1; const auto __n2 = __last2 - __first2; if (__n1 == 0) return __result; if (__n2 == 0) return __internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }, std::true_type()); _ForwardIterator1 __left_bound_seq_1 = std::lower_bound(__first1, __last1, *__first2, __comp); if (__left_bound_seq_1 == __last1) return __internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }, std::true_type()); _ForwardIterator2 __left_bound_seq_2 = std::lower_bound(__first2, __last2, *__first1, __comp); if (__left_bound_seq_2 == __last2) return __internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }, std::true_type()); if (__n1 + __n2 > __set_algo_cut_off) return __internal::__parallel_set_op( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n; }, [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _T* __result, _Compare __comp) { return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); }, __is_vector); return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::false_type) noexcept { return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, std::true_type) noexcept { ; return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); } template _OutputIterator __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector); } template _OutputIterator __pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector, std::true_type) { const auto __n1 = __last1 - __first1; const auto __n2 = __last2 - __first2; if (__n1 + __n2 <= __set_algo_cut_off) return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); typedef typename std::iterator_traits<_OutputIterator>::value_type _T; return __internal::__parallel_set_union_op( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _T* __result, _Compare __comp) { return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp); }, __is_vector); } template _RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, std::false_type) noexcept { return std::is_heap_until(__first, __last, __comp); } template _RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, std::true_type) noexcept { if (__last - __first < 2) return __last; typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType; return __unseq_backend::__simd_first( __first, _SizeType(0), __last - __first, [&__comp](_RandomAccessIterator __it, _SizeType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); }); } template _RandomAccessIterator __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_is_heap_until(__first, __last, __comp, __is_vector); } template _RandomAccessIterator __is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp, std::false_type) noexcept { _DifferenceType __i = __begin; for (; __i < __end; ++__i) { if (__comp(__first[(__i - 1) / 2], __first[__i])) { break; } } return __first + __i; } template _RandomAccessIterator __is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp, std::true_type) noexcept { return __unseq_backend::__simd_first( __first, __begin, __end, [&__comp](_RandomAccessIterator __it, _DifferenceType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); }); } template _RandomAccessIterator __pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, std::true_type) noexcept { if (__last - __first < 2) return __last; return __internal::__except_handler([&]() { return __parallel_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__first, __comp, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) { return __internal::__is_heap_until_local(__first, __i - __first, __j - __first, __comp, __is_vector); }, std::less::difference_type>(), true); }); } template _ForwardIterator __brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, std::false_type) noexcept { return std::min_element(__first, __last, __comp); } template _ForwardIterator __brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, std::true_type) noexcept { return __unseq_backend::__simd_min_element(__first, __last - __first, __comp); } template _ForwardIterator __pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_min_element(__first, __last, __comp, __is_vector); } template _RandomAccessIterator __pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector, std::true_type) { if (__first == __last) return __last; return __internal::__except_handler([&]() { return __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, __first, [=](_RandomAccessIterator __begin, _RandomAccessIterator __end, _RandomAccessIterator __init) -> _RandomAccessIterator { const _RandomAccessIterator subresult = __internal::__brick_min_element(__begin, __end, __comp, __is_vector); return __internal::__cmp_iterators_by_values(__init, subresult, __comp); }, [=](_RandomAccessIterator __it1, _RandomAccessIterator __it2) -> _RandomAccessIterator { return __internal::__cmp_iterators_by_values(__it1, __it2, __comp); }); }); } template std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, std::false_type) noexcept { return std::minmax_element(__first, __last, __comp); } template std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp, std::true_type) noexcept { return __unseq_backend::__simd_minmax_element(__first, __last - __first, __comp); } template std::pair<_ForwardIterator, _ForwardIterator> __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_minmax_element(__first, __last, __comp, __is_vector); } template std::pair<_ForwardIterator, _ForwardIterator> __pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp, _IsVector __is_vector, std::true_type) { if (__first == __last) return std::make_pair(__first, __first); return __internal::__except_handler([&]() { typedef std::pair<_ForwardIterator, _ForwardIterator> _Result; return __par_backend::__parallel_reduce( std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, std::make_pair(__first, __first), [=](_ForwardIterator __begin, _ForwardIterator __end, _Result __init) -> _Result { const _Result __subresult = __internal::__brick_minmax_element(__begin, __end, __comp, __is_vector); return std::make_pair(__internal::__cmp_iterators_by_values(__subresult.first, __init.first, __comp), __internal::__cmp_iterators_by_values(__init.second, __subresult.second, __not_pred<_Compare>(__comp))); }, [=](_Result __p1, _Result __p2) -> _Result { return std::make_pair( __internal::__cmp_iterators_by_values(__p1.first, __p2.first, __comp), __internal::__cmp_iterators_by_values(__p2.second, __p1.second, __not_pred<_Compare>(__comp))); }); }); } template std::pair<_ForwardIterator1, _ForwardIterator2> __mismatch_serial(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) { return std::mismatch(__first1, __last1, __first2, __last2, __pred); } template std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, std::false_type) noexcept { return __mismatch_serial(__first1, __last1, __first2, __last2, __pred); } template std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, std::true_type) noexcept { auto __n = std::min(__last1 - __first1, __last2 - __first2); return __unseq_backend::__simd_first(__first1, __n, __first2, __not_pred<_Predicate>(__pred)); } template std::pair<_ForwardIterator1, _ForwardIterator2> __pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector); } template std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred, _IsVector __is_vector, std::true_type) noexcept { return __internal::__except_handler([&]() { auto __n = std::min(__last1 - __first1, __last2 - __first2); auto __result = __internal::__parallel_find( std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, [__first1, __first2, __pred, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) { return __internal::__brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), __pred, __is_vector) .first; }, std::less::difference_type>(), true); return std::make_pair(__result, __first2 + (__result - __first1)); }); } template bool __brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, std::false_type) noexcept { return std::lexicographical_compare(__first1, __last1, __first2, __last2, __comp); } template bool __brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, std::true_type) noexcept { if (__first2 == __last2) { return false; } else if (__first1 == __last1) { return true; } else { typedef typename std::iterator_traits<_ForwardIterator1>::reference ref_type1; typedef typename std::iterator_traits<_ForwardIterator2>::reference ref_type2; --__last1; --__last2; auto __n = std::min(__last1 - __first1, __last2 - __first2); std::pair<_ForwardIterator1, _ForwardIterator2> __result = __unseq_backend::__simd_first( __first1, __n, __first2, [__comp](const ref_type1 __x, const ref_type2 __y) mutable { return __comp(__x, __y) || __comp(__y, __x); }); if (__result.first == __last1 && __result.second != __last2) { return !__comp(*__result.second, *__result.first); } else { return __comp(*__result.first, *__result.second); } } } template bool __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector); } template bool __pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector, std::true_type) noexcept { if (__first2 == __last2) { return false; } else if (__first1 == __last1) { return true; } else { typedef typename std::iterator_traits<_ForwardIterator1>::reference _RefType1; typedef typename std::iterator_traits<_ForwardIterator2>::reference _RefType2; --__last1; --__last2; auto __n = std::min(__last1 - __first1, __last2 - __first2); auto __result = __internal::__parallel_find( std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, [__first1, __first2, &__comp, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) { return __internal::__brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), [&__comp](const _RefType1 __x, const _RefType2 __y) { return !__comp(__x, __y) && !__comp(__y, __x); }, __is_vector) .first; }, std::less::difference_type>(), true); if (__result == __last1 && __first2 + (__result - __first1) != __last2) { return !__comp(*(__first2 + (__result - __first1)), *__result); } else { return __comp(*__result, *(__first2 + (__result - __first1))); } } } } } # 51 "/usr/include/c++/10/pstl/glue_execution_defs.h" 2 3 # 1 "/usr/include/c++/10/pstl/numeric_impl.h" 1 3 # 18 "/usr/include/c++/10/pstl/numeric_impl.h" 3 # 1 "/usr/include/c++/10/pstl/pstl_config.h" 1 3 # 19 "/usr/include/c++/10/pstl/numeric_impl.h" 2 3 # 1 "/usr/include/c++/10/pstl/algorithm_fwd.h" 1 3 # 16 "/usr/include/c++/10/pstl/algorithm_fwd.h" 3 namespace __pstl { namespace __internal { template bool __brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, std::false_type) noexcept; template bool __brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred, std::true_type) noexcept; template bool __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, std::false_type) noexcept; template bool __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector, std::true_type); template void __brick_walk1(_ForwardIterator, _ForwardIterator, _Function, std::false_type) noexcept; template void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function, std::true_type) noexcept; template void __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, std::false_type) noexcept; template void __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector, std::true_type); template void __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, std::false_type) noexcept; template void __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick, std::true_type); template _ForwardIterator __brick_walk1_n(_ForwardIterator, _Size, _Function, std::false_type); template _RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function, std::true_type) noexcept; template _ForwardIterator __pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector, std::false_type) noexcept; template _RandomAccessIterator __pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector, std::true_type); template _ForwardIterator __pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick, std::false_type) noexcept; template _RandomAccessIterator __pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick, std::true_type); template _ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, std::false_type) noexcept; template _ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, std::true_type) noexcept; template _ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, std::false_type) noexcept; template _ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function, std::true_type) noexcept; template _ForwardIterator2 __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, std::false_type) noexcept; template _ForwardIterator2 __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector, std::true_type); template _ForwardIterator2 __pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector, std::false_type) noexcept; template _RandomAccessIterator2 __pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector, std::true_type); template _ForwardIterator2 __pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick, std::false_type) noexcept; template _RandomAccessIterator2 __pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Brick, std::true_type); template _ForwardIterator2 __pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick, std::false_type) noexcept; template _RandomAccessIterator2 __pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick, std::true_type); template _ForwardIterator3 __brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function, std::false_type) noexcept; template _RandomAccessIterator3 __brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, _Function, std::true_type) noexcept; template _ForwardIterator3 __pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function, _IsVector, std::false_type) noexcept; template _RandomAccessIterator3 __pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, _Function, _IsVector, std::true_type); template bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, std::false_type) noexcept; template bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, std::true_type) noexcept; template bool __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, _IsVector, std::false_type) noexcept; template bool __pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, _IsVector, std::true_type); template bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, std::false_type) noexcept; template bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, _BinaryPredicate, std::true_type) noexcept; template bool __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, _IsVector, std::false_type) noexcept; template bool __pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, _BinaryPredicate, _IsVector, std::true_type); template _ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate, std::false_type) noexcept; template _RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate, std::true_type) noexcept; template _ForwardIterator __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, std::false_type) noexcept; template _ForwardIterator __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector, std::true_type); template _ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, std::false_type) noexcept; template _ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, std::true_type) noexcept; template _ForwardIterator1 __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, _IsVector, std::false_type) noexcept; template _ForwardIterator1 __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, _IsVector, std::true_type) noexcept; template _ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, std::false_type) noexcept; template _ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, std::true_type) noexcept; template _ForwardIterator1 __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, _IsVector, std::false_type) noexcept; template _ForwardIterator1 __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, _IsVector, std::true_type) noexcept; template _ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, std::false_type) noexcept; template _ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, std::true_type) noexcept; template _ForwardIterator1 __pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, _IsVector, std::false_type) noexcept; template _ForwardIterator1 __pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate, _IsVector, std::true_type) noexcept; template _ForwardIterator __brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, std::false_type) noexcept; template _ForwardIterator __brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, std::true_type) noexcept; template _ForwardIterator __pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, IsVector, std::false_type) noexcept; template _RandomAccessIterator __pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, _BinaryPredicate, IsVector, std::true_type) noexcept; template _OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator, std::false_type) noexcept; template _OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator, std::true_type) noexcept; template _OutputIterator __brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator, std::false_type) noexcept; template _OutputIterator __brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, std::true_type) noexcept; template _OutputIterator __brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator, std::false_type) noexcept; template _OutputIterator __brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, std::true_type) noexcept; template _OutputIterator __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::false_type) noexcept; template _OutputIterator __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, std::true_type) noexcept; template _OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, std::false_type) noexcept; template _OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, std::true_type) noexcept; template std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate, std::false_type) noexcept; template std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate, std::true_type) noexcept; template void __brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*, std::false_type) noexcept; template void __brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict, std::true_type) noexcept; template void __brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*, std::false_type) noexcept; template void __brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*, std::true_type) noexcept; template _OutputIterator __pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate, _IsVector, std::true_type); template typename std::iterator_traits<_ForwardIterator>::difference_type __brick_count(_ForwardIterator, _ForwardIterator, _Predicate, std::true_type) noexcept; template typename std::iterator_traits<_ForwardIterator>::difference_type __brick_count(_ForwardIterator, _ForwardIterator, _Predicate, std::false_type) noexcept; template typename std::iterator_traits<_ForwardIterator>::difference_type __pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, std::false_type, _IsVector) noexcept; template typename std::iterator_traits<_ForwardIterator>::difference_type __pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, std::true_type, _IsVector); template _ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, std::false_type) noexcept; template _ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate, std::true_type) noexcept; template _ForwardIterator __pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, std::false_type) noexcept; template _ForwardIterator __pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector, std::true_type) noexcept; template OutputIterator __brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, std::false_type) noexcept; template _OutputIterator __brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate, std::true_type) noexcept; template _OutputIterator __pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryPredicate, _IsVector, std::false_type) noexcept; template _DifferenceType __brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, std::false_type) noexcept; template _DifferenceType __brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate, std::true_type) noexcept; template _OutputIterator __pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate, _IsVector, std::true_type); template void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, std::false_type) noexcept; template void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, std::true_type) noexcept; template void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, std::false_type) noexcept; template void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, std::true_type) noexcept; template void __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, std::false_type) noexcept; template void __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector, std::true_type); template _OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, std::false_type) noexcept; template _OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator, std::true_type) noexcept; template _OutputIterator __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector, std::true_type); template _ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, std::false_type) noexcept; template _ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator, std::true_type) noexcept; template _ForwardIterator __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, std::false_type) noexcept; template _ForwardIterator __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector, std::true_type); template _OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, std::false_type) noexcept; template _OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, std::true_type) noexcept; template _OutputIterator __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector, std::true_type); template bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, std::false_type) noexcept; template bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate, std::true_type) noexcept; template bool __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, std::false_type) noexcept; template bool __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, std::true_type); template _ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, std::false_type) noexcept; template _ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate, std::true_type) noexcept; template _ForwardIterator __pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, std::false_type) noexcept; template _ForwardIterator __pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, std::true_type); template _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, std::false_type) noexcept; template _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, std::true_type) noexcept; template _BidirectionalIterator __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, _IsVector, std::false_type) noexcept; template _BidirectionalIterator __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate, _IsVector, std::true_type) noexcept; template std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, std::false_type) noexcept; template std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, std::true_type) noexcept; template std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, _IsVector, std::false_type) noexcept; template std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate, _IsVector, std::true_type); template void __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector , std::false_type, _IsMoveConstructible) noexcept; template void __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector , std::true_type, std::true_type); template void __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector , std::false_type) noexcept; template void __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector , std::true_type); template void __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::false_type) noexcept; template void __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::true_type); template _RandomAccessIterator __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::false_type) noexcept; template _RandomAccessIterator __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::true_type); template _ForwardIterator __brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, std::true_type, bool) noexcept; template _ForwardIterator __brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate, std::false_type, bool) noexcept; template _ForwardIterator __pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, std::false_type, _IsVector, bool) noexcept; template _RandomAccessIterator __pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate, std::true_type, _IsVector, bool); template void __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::false_type) noexcept; template void __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::true_type) noexcept; template void __brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, std::true_type) noexcept; template void __brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&, std::false_type) noexcept; template void __pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, std::false_type, _IsVector) noexcept; template _ForwardIterator __pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&, std::true_type, _IsVector); template _OutputIterator __brick_fill_n(_OutputIterator, _Size, const _Tp&, std::true_type) noexcept; template _OutputIterator __brick_fill_n(_OutputIterator, _Size, const _Tp&, std::false_type) noexcept; template _OutputIterator __pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, std::false_type, _IsVector) noexcept; template _OutputIterator __pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&, std::true_type, _IsVector); template void __brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator, std::true_type) noexcept; template void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator, std::false_type) noexcept; template void __pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, std::false_type, _IsVector) noexcept; template _ForwardIterator __pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator, std::true_type, _IsVector); template OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, std::true_type) noexcept; template OutputIterator __brick_generate_n(OutputIterator, Size, _Generator, std::false_type) noexcept; template OutputIterator __pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, std::false_type, _IsVector) noexcept; template OutputIterator __pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator, std::true_type, _IsVector); template _ForwardIterator __brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate, std::false_type) noexcept; template _RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate, std::true_type) noexcept; template _ForwardIterator __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, std::false_type) noexcept; template _ForwardIterator __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector, std::true_type) noexcept; template _OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::false_type) noexcept; template _OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::true_type) noexcept; template _OutputIterator __pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector, std::true_type); template void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, std::false_type) noexcept; template void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, std::true_type) noexcept; template void __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector, std::false_type) noexcept; template void __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector, std::true_type); template bool __pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector, std::false_type) noexcept; template bool __pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector, std::true_type); template _OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::false_type) noexcept; template _OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::true_type) noexcept; template _OutputIterator __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::true_type); template _OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::false_type) noexcept; template _OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::true_type) noexcept; template _OutputIterator __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::true_type); template _OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::false_type) noexcept; template _OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::true_type) noexcept; template _OutputIterator __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::true_type); template _OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::false_type) noexcept; template _OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, std::true_type) noexcept; template _OutputIterator __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare, _IsVector, std::true_type); template _RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, std::false_type) noexcept; template _RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare, std::true_type) noexcept; template _RandomAccessIterator __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::false_type) noexcept; template _RandomAccessIterator __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::true_type) noexcept; template _ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, std::false_type) noexcept; template _ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare, std::true_type) noexcept; template _ForwardIterator __pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, std::false_type) noexcept; template _RandomAccessIterator __pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector, std::true_type); template std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, std::false_type) noexcept; template std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare, std::true_type) noexcept; template std::pair<_ForwardIterator, _ForwardIterator> __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, std::false_type) noexcept; template std::pair<_ForwardIterator, _ForwardIterator> __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector, std::true_type); template std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate, std::false_type) noexcept; template std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate, std::true_type) noexcept; template std::pair<_ForwardIterator1, _ForwardIterator2> __pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate, _IsVector, std::false_type) noexcept; template std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, _Predicate, _IsVector, std::true_type) noexcept; template bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, std::false_type) noexcept; template bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, std::true_type) noexcept; template bool __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector, std::false_type) noexcept; template bool __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector, std::true_type) noexcept; } } # 22 "/usr/include/c++/10/pstl/numeric_impl.h" 2 3 namespace __pstl { namespace __internal { template _Tp __brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, std::false_type) noexcept { return std::inner_product(__first1, __last1, __first2, __init, __binary_op1, __binary_op2); } template _Tp __brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType; return __unseq_backend::__simd_transform_reduce( __last1 - __first1, __init, __binary_op1, [=, &__binary_op2](_DifferenceType __i) { return __binary_op2(__first1[__i], __first2[__i]); }); } template _Tp __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, _IsVector __is_vector, std::false_type) noexcept { return __brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector); } template _Tp __pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2, _IsVector __is_vector, std::true_type) { return __internal::__except_handler([&]() { return __par_backend::__parallel_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, [__first1, __first2, __binary_op2](_RandomAccessIterator1 __i) mutable { return __binary_op2(*__i, *(__first2 + (__i - __first1))); }, __init, __binary_op1, [__first1, __first2, __binary_op1, __binary_op2, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j, _Tp __init) -> _Tp { return __internal::__brick_transform_reduce(__i, __j, __first2 + (__i - __first1), __init, __binary_op1, __binary_op2, __is_vector); }); }); } template _Tp __brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op, std::false_type) noexcept { for (; __first != __last; ++__first) { __init = __binary_op(__init, __unary_op(*__first)); } return __init; } template _Tp __brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op, std::true_type) noexcept { typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType; return __unseq_backend::__simd_transform_reduce( __last - __first, __init, __binary_op, [=, &__unary_op](_DifferenceType __i) { return __unary_op(__first[__i]); }); } template _Tp __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector); } template _Tp __pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector, std::true_type) { return __internal::__except_handler([&]() { return __par_backend::__parallel_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, [__unary_op](_ForwardIterator __i) mutable { return __unary_op(*__i); }, __init, __binary_op, [__unary_op, __binary_op, __is_vector](_ForwardIterator __i, _ForwardIterator __j, _Tp __init) { return __internal::__brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector); }); }); } # 148 "/usr/include/c++/10/pstl/numeric_impl.h" 3 template std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, std::false_type, std::false_type) noexcept { for (; __first != __last; ++__first, ++__result) { *__result = __init; __init = __binary_op(__init, __unary_op(*__first)); } return std::make_pair(__result, __init); } template std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, std::true_type, std::false_type) noexcept { for (; __first != __last; ++__first, ++__result) { __init = __binary_op(__init, __unary_op(*__first)); *__result = __init; } return std::make_pair(__result, __init); } template using is_arithmetic_udop = std::integral_constant::value && !std::is_same<_BinaryOperation, std::plus<_Tp>>::value>; template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, std::true_type) noexcept { return __unseq_backend::__simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op, _Inclusive()); } template typename std::enable_if::value, std::pair<_OutputIterator, _Tp>>::type __brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, std::true_type) noexcept { return __internal::__brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), std::false_type()); } template _OutputIterator __pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), __is_vector) .first; } template typename std::enable_if::value, _OutputIterator>::type __pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; return __internal::__except_handler([&]() { __par_backend::__parallel_transform_scan( std::forward<_ExecutionPolicy>(__exec), __last - __first, [__first, __unary_op](_DifferenceType __i) mutable { return __unary_op(__first[__i]); }, __init, __binary_op, [__first, __unary_op, __binary_op](_DifferenceType __i, _DifferenceType __j, _Tp __init) { return __internal::__brick_transform_reduce(__first + __i, __first + __j, __init, __binary_op, __unary_op, std::false_type()); }, [__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __j, _Tp __init) { return __internal::__brick_transform_scan(__first + __i, __first + __j, __result + __i, __unary_op, __init, __binary_op, _Inclusive(), __is_vector) .second; }); return __result + (__last - __first); }); } template typename std::enable_if::value, _OutputIterator>::type __pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive, _IsVector __is_vector, std::true_type) { typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType; _DifferenceType __n = __last - __first; if (__n <= 0) { return __result; } return __internal::__except_handler([&]() { __par_backend::__parallel_strict_scan( std::forward<_ExecutionPolicy>(__exec), __n, __init, [__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __len) { return __internal::__brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i, __unary_op, _Tp{}, __binary_op, _Inclusive(), __is_vector) .second; }, __binary_op, [__result, &__binary_op](_DifferenceType __i, _DifferenceType __len, _Tp __initial) { return *(std::transform(__result + __i, __result + __i + __len, __result + __i, [&__initial, &__binary_op](const _Tp& __x) { return __binary_op(__initial, __x); }) - 1); }, [](_Tp __res) {}); return __result + (__last - __first); }); } template _OutputIterator __brick_adjacent_difference(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first, _BinaryOperation __op, std::false_type) noexcept { return std::adjacent_difference(__first, __last, __d_first, __op); } template _ForwardIterator2 __brick_adjacent_difference(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, BinaryOperation __op, std::true_type) noexcept { ; typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1; typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2; auto __n = __last - __first; *__d_first = *__first; return __unseq_backend::__simd_walk_3( __first + 1, __n - 1, __first, __d_first + 1, [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__x, __y); }); } template _OutputIterator __pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector, std::false_type) noexcept { return __internal::__brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector); } template _ForwardIterator2 __pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector, std::true_type) { ; typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1; typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2; *__d_first = *__first; __par_backend::__parallel_for( std::forward<_ExecutionPolicy>(__exec), __first, __last - 1, [&__op, __is_vector, __d_first, __first](_ForwardIterator1 __b, _ForwardIterator1 __e) { _ForwardIterator2 __d_b = __d_first + (__b - __first); __internal::__brick_walk3( __b, __e, __b + 1, __d_b + 1, [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__y, __x); }, __is_vector); }); return __d_first + (__last - __first); } } } # 52 "/usr/include/c++/10/pstl/glue_execution_defs.h" 2 3 # 33 "/usr/include/c++/10/execution" 2 3 # 1 "/usr/include/c++/10/pstl/glue_algorithm_impl.h" 1 3 # 18 "/usr/include/c++/10/pstl/glue_algorithm_impl.h" 3 # 1 "/usr/include/c++/10/pstl/numeric_fwd.h" 1 3 # 16 "/usr/include/c++/10/pstl/numeric_fwd.h" 3 namespace __pstl { namespace __internal { template _Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, _BinaryOperation2, std::true_type) noexcept; template _Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, _BinaryOperation2, std::false_type) noexcept; template _Tp __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1, _BinaryOperation2, _IsVector, std::false_type) noexcept; template _Tp __pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Tp, _BinaryOperation1, _BinaryOperation2, _IsVector __is_vector, std::true_type); template _Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, std::true_type) noexcept; template _Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, std::false_type) noexcept; template _Tp __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector, std::false_type) noexcept; template _Tp __pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector, std::true_type); template std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation, std::false_type) noexcept; template std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation, std::true_type) noexcept; template _OutputIterator __pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, std::false_type) noexcept; template typename std::enable_if::value, _OutputIterator>::type __pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, std::true_type); template typename std::enable_if::value, _OutputIterator>::type __pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, std::true_type); template _OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, std::false_type) noexcept; template _OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, std::true_type) noexcept; template _OutputIterator __pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, _IsVector, std::false_type) noexcept; template _OutputIterator __pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation, _IsVector, std::true_type); } } # 19 "/usr/include/c++/10/pstl/glue_algorithm_impl.h" 2 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { using namespace __pstl; return __internal::__pattern_any_of( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) { return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__not_pred<_Pred>(__pred)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f) { using namespace __pstl; __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, __f, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f) { using namespace __pstl; return __internal::__pattern_walk1_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __f, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { using namespace __pstl; return __internal::__pattern_find_if( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__not_pred<_Predicate>(__pred)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__equal_value<_Tp>(__value)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_find_end( std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last) { return std::find_end(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_find_first_of( std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last) { return std::find_first_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; using namespace __pstl; return __internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<_ValueType>(), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), false); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), false); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::difference_type> count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; using namespace __pstl; return __internal::__pattern_count( std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value](const _ValueType& __x) { return __value == __x; }, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::difference_type> count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { using namespace __pstl; return __internal::__pattern_count( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_search( std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, _ForwardIterator2 __s_last) { return std::search(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_search_n( std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) { return std::search_n(std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, std::equal_to::value_type>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) { using namespace __pstl; const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); return __internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result) { using namespace __pstl; const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); return __internal::__pattern_walk2_brick_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [__is_vector](_ForwardIterator1 __begin, _Size __sz, _ForwardIterator2 __res) { return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector); }, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Predicate __pred) { using namespace __pstl; return __internal::__pattern_copy_if( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { using namespace __pstl; typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1; typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2; return __internal::__pattern_walk2( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, [](_ReferenceType1 __x, _ReferenceType2 __y) { using std::swap; swap(__x, __y); }, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _UnaryOperation __op) { typedef typename iterator_traits<_ForwardIterator1>::reference _InputType; typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType; using namespace __pstl; return __internal::__pattern_walk2( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__op](_InputType __x, _OutputType __y) mutable { __y = __op(__x); }, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator __result, _BinaryOperation __op) { typedef typename iterator_traits<_ForwardIterator1>::reference _Input1Type; typedef typename iterator_traits<_ForwardIterator2>::reference _Input2Type; typedef typename iterator_traits<_ForwardIterator>::reference _OutputType; using namespace __pstl; return __internal::__pattern_walk3( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __result, [__op](_Input1Type x, _Input2Type y, _OutputType z) mutable { z = __op(x, y); }, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, const _Tp& __new_value) { using namespace __pstl; typedef typename iterator_traits<_ForwardIterator>::reference _ElementType; __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__pred, &__new_value](_ElementType __elem) { if (__pred(__elem)) { __elem = __new_value; } }, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) { std::replace_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value) { typedef typename iterator_traits<_ForwardIterator1>::reference _InputType; typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType; using namespace __pstl; return __internal::__pattern_walk2( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__pred, &__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; }, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, const _Tp& __old_value, const _Tp& __new_value) { return std::replace_copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { using namespace __pstl; __internal::__pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __last, __value, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value) { if (__count <= 0) return __first; using namespace __pstl; return __internal::__pattern_fill_n( std::forward<_ExecutionPolicy>(__exec), __first, __count, __value, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g) { using namespace __pstl; __internal::__pattern_generate( std::forward<_ExecutionPolicy>(__exec), __first, __last, __g, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, _Generator __g) { if (__count <= 0) return __first; using namespace __pstl; return __internal::__pattern_generate_n( std::forward<_ExecutionPolicy>(__exec), __first, __count, __g, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Predicate __pred) { return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pstl::__internal::__not_pred<_Predicate>(__pred)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, const _Tp& __value) { return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pstl::__internal::__not_equal_value<_Tp>(__value)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_remove_if( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { return std::remove_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__equal_value<_Tp>(__value)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_unique( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { return std::unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_unique_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) { return std::unique_copy(__exec, __first, __last, __result, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last) { using namespace __pstl; __internal::__pattern_reverse( std::forward<_ExecutionPolicy>(__exec), __first, __last, __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _ForwardIterator __d_first) { using namespace __pstl; return __internal::__pattern_reverse_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) { using namespace __pstl; return __internal::__pattern_rotate( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last, _ForwardIterator2 __result) { using namespace __pstl; return __internal::__pattern_rotate_copy( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __result, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_is_partitioned( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_partition( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_stable_partition( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_partition_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __out_true, __out_false, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType; using namespace __pstl; return __internal::__pattern_sort( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), typename std::is_move_constructible<_InputType>::type()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; std::sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; return __internal::__pattern_stable_sort( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; std::stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) { using namespace __pstl; return __internal::__pattern_mismatch( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pred, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred) { return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, std::next(__first2, std::distance(__first1, __last1)), __pred); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, std::next(__first2, std::distance(__first1, __last1))); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p) { using namespace __pstl; return __internal::__pattern_equal( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { return std::equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __p) { using namespace __pstl; return __internal::__pattern_equal( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __p, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { return std::equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pstl::__internal::__pstl_equal()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first) { using namespace __pstl; const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec); return __internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) { return __internal::__brick_move(__begin, __end, __res, __is_vector); }, __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; __internal::__pattern_partial_sort( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType; std::partial_sort(std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp) { using namespace __pstl; return __internal::__pattern_partial_sort_copy( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __d_first, _RandomAccessIterator __d_last) { return std::partial_sort_copy(std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __pstl::__internal::__pstl_less()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; const _ForwardIterator __res = __internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__reorder_pred<_Compare>(__comp), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), false); return __res == __last ? __last : std::next(__res); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; return is_sorted_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; return __internal::__pattern_adjacent_find( std::forward<_ExecutionPolicy>(__exec), __first, __last, __internal::__reorder_pred<_Compare>(__comp), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), true) == __last; } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; return std::is_sorted(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp) { using namespace __pstl; return __internal::__pattern_merge( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __d_first) { return std::merge(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __pstl::__internal::__pstl_less()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp) { using namespace __pstl; __internal::__pattern_inplace_merge( std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) { typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _InputType; std::inplace_merge(std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp) { using namespace __pstl; return __internal::__pattern_includes( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { return std::includes(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pstl::__internal::__pstl_less()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) { using namespace __pstl; return __internal::__pattern_set_union( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result) { return std::set_union(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __pstl::__internal::__pstl_less()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) { using namespace __pstl; return __internal::__pattern_set_intersection( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result) { return std::set_intersection(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __pstl::__internal::__pstl_less()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) { using namespace __pstl; return __internal::__pattern_set_difference( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result) { return std::set_difference(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __pstl::__internal::__pstl_less()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp) { using namespace __pstl; return __internal::__pattern_set_symmetric_difference( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result) { return std::set_symmetric_difference(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __pstl::__internal::__pstl_less()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; return __internal::__pattern_is_heap_until( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp) == __last; } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) { typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType; return std::is_heap(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; return __internal::__pattern_min_element( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { return min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__reorder_pred<_Compare>(__comp)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType; return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__reorder_pred>(std::less<_InputType>())); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) { using namespace __pstl; return __internal::__pattern_minmax_element( std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; return std::minmax_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_ValueType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) { using namespace __pstl; __internal::__pattern_nth_element( std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType; std::nth_element(std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, std::less<_InputType>()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp) { using namespace __pstl; return __internal::__pattern_lexicographical_compare( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) { return std::lexicographical_compare(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pstl::__internal::__pstl_less()); } } # 39 "/usr/include/c++/10/execution" 2 3 # 1 "/usr/include/c++/10/pstl/glue_numeric_impl.h" 1 3 # 18 "/usr/include/c++/10/pstl/glue_numeric_impl.h" 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op) { return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __pstl::__internal::__no_op()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init) { return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, std::plus<_Tp>(), __pstl::__internal::__no_op()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::value_type> reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, _ValueType{}, std::plus<_ValueType>(), __pstl::__internal::__no_op()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init) { typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType; using namespace __pstl; return __internal::__pattern_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, std::plus<_InputType>(), std::multiplies<_InputType>(), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2) { using namespace __pstl; return __internal::__pattern_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, __binary_op1, __binary_op2, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op) { using namespace __pstl; return __internal::__pattern_transform_reduce( std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __unary_op, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Tp __init) { return transform_exclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __init, std::plus<_Tp>(), __pstl::__internal::__no_op()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op) { return transform_exclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __init, __binary_op, __pstl::__internal::__no_op()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) { typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType; return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, std::plus<_InputType>(), __pstl::__internal::__no_op()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op) { return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __binary_op, __pstl::__internal::__no_op()); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init) { return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __binary_op, __pstl::__internal::__no_op(), __init); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __unary_op) { using namespace __pstl; return __internal::__pattern_transform_scan( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op, std::false_type(), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op, _Tp __init) { using namespace __pstl; return __internal::__pattern_transform_scan( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op, std::true_type(), __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op) { if (__first != __last) { auto __tmp = __unary_op(*__first); *__result = __tmp; return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), ++__first, __last, ++__result, __binary_op, __unary_op, __tmp); } else { return __result; } } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first, _BinaryOperation __op) { if (__first == __last) return __d_first; using namespace __pstl; return __internal::__pattern_adjacent_difference( std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __op, __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec), __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec)); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first) { typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType; return adjacent_difference(std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, std::minus<_ValueType>()); } } # 44 "/usr/include/c++/10/execution" 2 3 # 1 "/usr/include/c++/10/pstl/glue_memory_impl.h" 1 3 # 16 "/usr/include/c++/10/pstl/glue_memory_impl.h" 3 namespace std { template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); return __internal::__invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { return __internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }, __is_parallel); }, [&]() { return __internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [](_ReferenceType1 __val1, _ReferenceType2 __val2) { ::new (std::addressof(__val2)) _ValueType2(__val1); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); return __internal::__invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { return __internal::__pattern_walk2_brick_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) { return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector); }, __is_parallel); }, [&]() { return __internal::__pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [](_ReferenceType1 __val1, _ReferenceType2 __val2) { ::new (std::addressof(__val2)) _ValueType2(__val1); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); return __internal::__invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { return __internal::__pattern_walk2_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) { return __internal::__brick_copy(__begin, __end, __res, __is_vector); }, __is_parallel); }, [&]() { return __internal::__pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, [](_ReferenceType1 __val1, _ReferenceType2 __val2) { ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result) { typedef typename iterator_traits<_InputIterator>::value_type _ValueType1; typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2; typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec); return __internal::__invoke_if_else( std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (), [&]() { return __internal::__pattern_walk2_brick_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) { return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector); }, __is_parallel); }, [&]() { return __internal::__pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result, [](_ReferenceType1 __val1, _ReferenceType2 __val2) { ::new (std::addressof(__val2)) _ValueType2(std::move(__val1)); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); __internal::__invoke_if_else(std::is_arithmetic<_ValueType>(), [&]() { __internal::__pattern_walk_brick( std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value, &__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { __internal::__brick_fill(__begin, __end, _ValueType(__value), __is_vector); }, __is_parallel); }, [&]() { __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(__value); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); return __internal::__invoke_if_else( std::is_arithmetic<_ValueType>(), [&]() { return __internal::__pattern_walk_brick_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, [&__value, &__is_vector](_ForwardIterator __begin, _Size __count) { return __internal::__brick_fill_n(__begin, __count, _ValueType(__value), __is_vector); }, __is_parallel); }, [&]() { return __internal::__pattern_walk1_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, [&__value](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(__value); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); __internal::__invoke_if_not(std::is_trivially_destructible<_ValueType>(), [&]() { __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); return __internal::__invoke_if_else( std::is_trivially_destructible<_ValueType>(), [&]() { return std::next(__first, __n); }, [&]() { return __internal::__pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); __internal::__invoke_if_not(std::is_trivial<_ValueType>(), [&]() { __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); return __internal::__invoke_if_else(std::is_trivial<_ValueType>(), [&]() { return std::next(__first, __n); }, [&]() { return __internal::__pattern_walk1_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); __internal::__invoke_if_else( std::is_trivial<_ValueType>(), [&]() { __internal::__pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last, [__is_vector](_ForwardIterator __begin, _ForwardIterator __end) { __internal::__brick_fill(__begin, __end, _ValueType(), __is_vector); }, __is_parallel); }, [&]() { __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, __is_vector, __is_parallel); }); } template __pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) { typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType; typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType; using namespace __pstl; const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec); return __internal::__invoke_if_else( std::is_trivial<_ValueType>(), [&]() { return __internal::__pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, [__is_vector](_ForwardIterator __begin, _Size __count) { return __internal::__brick_fill_n(__begin, __count, _ValueType(), __is_vector); }, __is_parallel); }, [&]() { return __internal::__pattern_walk1_n( std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, __is_vector, __is_parallel); }); } } # 49 "/usr/include/c++/10/execution" 2 3 # 71 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cfenv" 1 3 # 32 "/usr/include/c++/10/cfenv" 3 # 33 "/usr/include/c++/10/cfenv" 3 # 41 "/usr/include/c++/10/cfenv" 3 # 1 "/usr/include/c++/10/fenv.h" 1 3 # 32 "/usr/include/c++/10/fenv.h" 3 # 33 "/usr/include/c++/10/fenv.h" 3 # 1 "/usr/include/fenv.h" 1 3 4 # 26 "/usr/include/fenv.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 27 "/usr/include/fenv.h" 2 3 4 # 64 "/usr/include/fenv.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/fenv.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/fenv.h" 3 4 enum { FE_INVALID = 0x01, __FE_DENORM = 0x02, FE_DIVBYZERO = 0x04, FE_OVERFLOW = 0x08, FE_UNDERFLOW = 0x10, FE_INEXACT = 0x20 }; enum { FE_TONEAREST = 0, FE_DOWNWARD = 0x400, FE_UPWARD = 0x800, FE_TOWARDZERO = 0xc00 }; typedef unsigned short int fexcept_t; typedef struct { unsigned short int __control_word; unsigned short int __glibc_reserved1; unsigned short int __status_word; unsigned short int __glibc_reserved2; unsigned short int __tags; unsigned short int __glibc_reserved3; unsigned int __eip; unsigned short int __cs_selector; unsigned int __opcode:11; unsigned int __glibc_reserved4:5; unsigned int __data_offset; unsigned short int __data_selector; unsigned short int __glibc_reserved5; unsigned int __mxcsr; } fenv_t; # 106 "/usr/include/x86_64-linux-gnu/bits/fenv.h" 3 4 typedef struct { unsigned short int __control_word; unsigned short int __glibc_reserved; unsigned int __mxcsr; } femode_t; # 65 "/usr/include/fenv.h" 2 3 4 extern "C" { extern int feclearexcept (int __excepts) throw (); extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) throw (); extern int feraiseexcept (int __excepts) throw (); extern int fesetexcept (int __excepts) throw (); extern int fesetexceptflag (const fexcept_t *__flagp, int __excepts) throw (); extern int fetestexcept (int __excepts) throw (); extern int fetestexceptflag (const fexcept_t *__flagp, int __excepts) throw (); extern int fegetround (void) throw () __attribute__ ((__pure__)); extern int fesetround (int __rounding_direction) throw (); extern int fegetenv (fenv_t *__envp) throw (); extern int feholdexcept (fenv_t *__envp) throw (); extern int fesetenv (const fenv_t *__envp) throw (); extern int feupdateenv (const fenv_t *__envp) throw (); extern int fegetmode (femode_t *__modep) throw (); extern int fesetmode (const femode_t *__modep) throw (); # 161 "/usr/include/fenv.h" 3 4 extern int feenableexcept (int __excepts) throw (); extern int fedisableexcept (int __excepts) throw (); extern int fegetexcept (void) throw (); } # 37 "/usr/include/c++/10/fenv.h" 2 3 # 55 "/usr/include/c++/10/fenv.h" 3 namespace std { using ::fenv_t; using ::fexcept_t; using ::feclearexcept; using ::fegetexceptflag; using ::feraiseexcept; using ::fesetexceptflag; using ::fetestexcept; using ::fegetround; using ::fesetround; using ::fegetenv; using ::feholdexcept; using ::fesetenv; using ::feupdateenv; } # 42 "/usr/include/c++/10/cfenv" 2 3 # 58 "/usr/include/c++/10/cfenv" 3 namespace std { using ::fenv_t; using ::fexcept_t; using ::feclearexcept; using ::fegetexceptflag; using ::feraiseexcept; using ::fesetexceptflag; using ::fetestexcept; using ::fegetround; using ::fesetround; using ::fegetenv; using ::feholdexcept; using ::fesetenv; using ::feupdateenv; } # 73 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cmath" 1 3 # 39 "/usr/include/c++/10/cmath" 3 # 40 "/usr/include/c++/10/cmath" 3 # 1 "/usr/include/math.h" 1 3 4 # 27 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4 # 28 "/usr/include/math.h" 2 3 4 extern "C" { # 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4 # 25 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4 # 26 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 2 3 4 # 41 "/usr/include/math.h" 2 3 4 # 138 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h" 1 3 4 # 139 "/usr/include/math.h" 2 3 4 # 149 "/usr/include/math.h" 3 4 typedef float float_t; typedef double double_t; # 190 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/fp-logb.h" 1 3 4 # 191 "/usr/include/math.h" 2 3 4 # 233 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/fp-fast.h" 1 3 4 # 234 "/usr/include/math.h" 2 3 4 enum { FP_INT_UPWARD = 0, FP_INT_DOWNWARD = 1, FP_INT_TOWARDZERO = 2, FP_INT_TONEARESTFROMZERO = 3, FP_INT_TONEAREST = 4, }; # 289 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 # 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 extern int __fpclassify (double __value) throw () __attribute__ ((__const__)); extern int __signbit (double __value) throw () __attribute__ ((__const__)); extern int __isinf (double __value) throw () __attribute__ ((__const__)); extern int __finite (double __value) throw () __attribute__ ((__const__)); extern int __isnan (double __value) throw () __attribute__ ((__const__)); extern int __iseqsig (double __x, double __y) throw (); extern int __issignaling (double __value) throw () __attribute__ ((__const__)); # 290 "/usr/include/math.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern double acos (double __x) throw (); extern double __acos (double __x) throw (); extern double asin (double __x) throw (); extern double __asin (double __x) throw (); extern double atan (double __x) throw (); extern double __atan (double __x) throw (); extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw (); extern double cos (double __x) throw (); extern double __cos (double __x) throw (); extern double sin (double __x) throw (); extern double __sin (double __x) throw (); extern double tan (double __x) throw (); extern double __tan (double __x) throw (); extern double cosh (double __x) throw (); extern double __cosh (double __x) throw (); extern double sinh (double __x) throw (); extern double __sinh (double __x) throw (); extern double tanh (double __x) throw (); extern double __tanh (double __x) throw (); extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw () ; extern double acosh (double __x) throw (); extern double __acosh (double __x) throw (); extern double asinh (double __x) throw (); extern double __asinh (double __x) throw (); extern double atanh (double __x) throw (); extern double __atanh (double __x) throw (); extern double exp (double __x) throw (); extern double __exp (double __x) throw (); extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw (); extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw (); extern double log (double __x) throw (); extern double __log (double __x) throw (); extern double log10 (double __x) throw (); extern double __log10 (double __x) throw (); extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw (); extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw (); extern double log1p (double __x) throw (); extern double __log1p (double __x) throw (); extern double logb (double __x) throw (); extern double __logb (double __x) throw (); extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw (); extern double log2 (double __x) throw (); extern double __log2 (double __x) throw (); extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw (); extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw (); extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw (); extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw (); extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__)); extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__)); extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__)); extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw (); # 182 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern int finite (double __value) throw () __attribute__ ((__const__)); extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw (); extern double significand (double __x) throw (); extern double __significand (double __x) throw (); extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double nan (const char *__tagb) throw (); extern double __nan (const char *__tagb) throw (); # 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern double j0 (double) throw (); extern double __j0 (double) throw (); extern double j1 (double) throw (); extern double __j1 (double) throw (); extern double jn (int, double) throw (); extern double __jn (int, double) throw (); extern double y0 (double) throw (); extern double __y0 (double) throw (); extern double y1 (double) throw (); extern double __y1 (double) throw (); extern double yn (int, double) throw (); extern double __yn (int, double) throw (); extern double erf (double) throw (); extern double __erf (double) throw (); extern double erfc (double) throw (); extern double __erfc (double) throw (); extern double lgamma (double) throw (); extern double __lgamma (double) throw (); extern double tgamma (double) throw (); extern double __tgamma (double) throw (); extern double gamma (double) throw (); extern double __gamma (double) throw (); extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw (); extern double rint (double __x) throw (); extern double __rint (double __x) throw (); extern double nextafter (double __x, double __y) throw (); extern double __nextafter (double __x, double __y) throw (); extern double nexttoward (double __x, long double __y) throw (); extern double __nexttoward (double __x, long double __y) throw (); extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw (); extern double nextup (double __x) throw (); extern double __nextup (double __x) throw (); extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw (); extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw (); extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw (); extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw (); extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw (); extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw (); extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__)); extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__)); extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw (); extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw (); __extension__ extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw (); extern long int lround (double __x) throw (); extern long int __lround (double __x) throw (); __extension__ extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw (); extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw (); extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw (); extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfp (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) throw () ; extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern int canonicalize (double *__cx, const double *__x) throw (); extern int totalorder (const double *__x, const double *__y) throw () __attribute__ ((__pure__)); extern int totalordermag (const double *__x, const double *__y) throw () __attribute__ ((__pure__)); extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw (); extern int setpayload (double *__x, double __payload) throw (); extern int setpayloadsig (double *__x, double __payload) throw (); extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw (); # 291 "/usr/include/math.h" 2 3 4 # 306 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 # 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 extern int __fpclassifyf (float __value) throw () __attribute__ ((__const__)); extern int __signbitf (float __value) throw () __attribute__ ((__const__)); extern int __isinff (float __value) throw () __attribute__ ((__const__)); extern int __finitef (float __value) throw () __attribute__ ((__const__)); extern int __isnanf (float __value) throw () __attribute__ ((__const__)); extern int __iseqsigf (float __x, float __y) throw (); extern int __issignalingf (float __value) throw () __attribute__ ((__const__)); # 307 "/usr/include/math.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern float acosf (float __x) throw (); extern float __acosf (float __x) throw (); extern float asinf (float __x) throw (); extern float __asinf (float __x) throw (); extern float atanf (float __x) throw (); extern float __atanf (float __x) throw (); extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw (); extern float cosf (float __x) throw (); extern float __cosf (float __x) throw (); extern float sinf (float __x) throw (); extern float __sinf (float __x) throw (); extern float tanf (float __x) throw (); extern float __tanf (float __x) throw (); extern float coshf (float __x) throw (); extern float __coshf (float __x) throw (); extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw (); extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw (); extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw () ; extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw (); extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw (); extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw (); extern float expf (float __x) throw (); extern float __expf (float __x) throw (); extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw (); extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw (); extern float logf (float __x) throw (); extern float __logf (float __x) throw (); extern float log10f (float __x) throw (); extern float __log10f (float __x) throw (); extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw (); extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw (); extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw (); extern float logbf (float __x) throw (); extern float __logbf (float __x) throw (); extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw (); extern float log2f (float __x) throw (); extern float __log2f (float __x) throw (); extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw (); extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw (); extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw (); extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw (); extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__)); extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__)); extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__)); extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw (); # 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern int isinff (float __value) throw () __attribute__ ((__const__)); extern int finitef (float __value) throw () __attribute__ ((__const__)); extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw (); extern float significandf (float __x) throw (); extern float __significandf (float __x) throw (); extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float nanf (const char *__tagb) throw (); extern float __nanf (const char *__tagb) throw (); # 211 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern int isnanf (float __value) throw () __attribute__ ((__const__)); extern float j0f (float) throw (); extern float __j0f (float) throw (); extern float j1f (float) throw (); extern float __j1f (float) throw (); extern float jnf (int, float) throw (); extern float __jnf (int, float) throw (); extern float y0f (float) throw (); extern float __y0f (float) throw (); extern float y1f (float) throw (); extern float __y1f (float) throw (); extern float ynf (int, float) throw (); extern float __ynf (int, float) throw (); extern float erff (float) throw (); extern float __erff (float) throw (); extern float erfcf (float) throw (); extern float __erfcf (float) throw (); extern float lgammaf (float) throw (); extern float __lgammaf (float) throw (); extern float tgammaf (float) throw (); extern float __tgammaf (float) throw (); extern float gammaf (float) throw (); extern float __gammaf (float) throw (); extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw (); extern float rintf (float __x) throw (); extern float __rintf (float __x) throw (); extern float nextafterf (float __x, float __y) throw (); extern float __nextafterf (float __x, float __y) throw (); extern float nexttowardf (float __x, long double __y) throw (); extern float __nexttowardf (float __x, long double __y) throw (); extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw (); extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw (); extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw (); extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw (); extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw (); extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw (); extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw (); extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw (); extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__)); extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__)); extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw (); extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw (); __extension__ extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw (); extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw (); __extension__ extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw (); extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw (); extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw (); extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) throw () ; extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern int canonicalizef (float *__cx, const float *__x) throw (); extern int totalorderf (const float *__x, const float *__y) throw () __attribute__ ((__pure__)); extern int totalordermagf (const float *__x, const float *__y) throw () __attribute__ ((__pure__)); extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw (); extern int setpayloadf (float *__x, float __payload) throw (); extern int setpayloadsigf (float *__x, float __payload) throw (); extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw (); # 308 "/usr/include/math.h" 2 3 4 # 349 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 # 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 extern int __fpclassifyl (long double __value) throw () __attribute__ ((__const__)); extern int __signbitl (long double __value) throw () __attribute__ ((__const__)); extern int __isinfl (long double __value) throw () __attribute__ ((__const__)); extern int __finitel (long double __value) throw () __attribute__ ((__const__)); extern int __isnanl (long double __value) throw () __attribute__ ((__const__)); extern int __iseqsigl (long double __x, long double __y) throw (); extern int __issignalingl (long double __value) throw () __attribute__ ((__const__)); # 350 "/usr/include/math.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw (); extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw (); extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw (); extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw (); extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw (); extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw (); extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw (); extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw (); extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw (); extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw (); extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw () ; extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw (); extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw (); extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw (); extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw (); extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw (); extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw (); extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw (); extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw (); extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw (); extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw (); extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw (); extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw (); extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw (); extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw (); extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw (); extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw (); extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw (); extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw (); extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__)); extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__)); extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw (); # 177 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern int isinfl (long double __value) throw () __attribute__ ((__const__)); extern int finitel (long double __value) throw () __attribute__ ((__const__)); extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw (); extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw (); extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double nanl (const char *__tagb) throw (); extern long double __nanl (const char *__tagb) throw (); # 211 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern int isnanl (long double __value) throw () __attribute__ ((__const__)); extern long double j0l (long double) throw (); extern long double __j0l (long double) throw (); extern long double j1l (long double) throw (); extern long double __j1l (long double) throw (); extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw (); extern long double y0l (long double) throw (); extern long double __y0l (long double) throw (); extern long double y1l (long double) throw (); extern long double __y1l (long double) throw (); extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw (); extern long double erfl (long double) throw (); extern long double __erfl (long double) throw (); extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw (); extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw (); extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw (); extern long double gammal (long double) throw (); extern long double __gammal (long double) throw (); extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw (); extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw (); extern long double nextafterl (long double __x, long double __y) throw (); extern long double __nextafterl (long double __x, long double __y) throw (); extern long double nexttowardl (long double __x, long double __y) throw (); extern long double __nexttowardl (long double __x, long double __y) throw (); extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw (); extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw (); extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw (); extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw (); extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw (); extern long int llogbl (long double __x) throw (); extern long int __llogbl (long double __x) throw (); extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw (); extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw (); extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__)); extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__)); extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw (); extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw (); __extension__ extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw (); extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw (); __extension__ extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw (); extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw (); extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw (); extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) throw () ; extern long double fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern int canonicalizel (long double *__cx, const long double *__x) throw (); extern int totalorderl (const long double *__x, const long double *__y) throw () __attribute__ ((__pure__)); extern int totalordermagl (const long double *__x, const long double *__y) throw () __attribute__ ((__pure__)); extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw (); extern int setpayloadl (long double *__x, long double __payload) throw (); extern int setpayloadsigl (long double *__x, long double __payload) throw (); extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw (); # 351 "/usr/include/math.h" 2 3 4 # 389 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32 acosf32 (_Float32 __x) throw (); extern _Float32 __acosf32 (_Float32 __x) throw (); extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw (); extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw (); extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw (); extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw (); extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw (); extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw (); extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw (); extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw (); extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw (); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw () ; extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw (); extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw (); extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw (); extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw (); extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw (); extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw (); extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) throw (); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw (); extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw (); extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw (); extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw (); extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw (); extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw (); extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw (); extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw (); extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw (); # 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 nanf32 (const char *__tagb) throw (); extern _Float32 __nanf32 (const char *__tagb) throw (); # 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32 j0f32 (_Float32) throw (); extern _Float32 __j0f32 (_Float32) throw (); extern _Float32 j1f32 (_Float32) throw (); extern _Float32 __j1f32 (_Float32) throw (); extern _Float32 jnf32 (int, _Float32) throw (); extern _Float32 __jnf32 (int, _Float32) throw (); extern _Float32 y0f32 (_Float32) throw (); extern _Float32 __y0f32 (_Float32) throw (); extern _Float32 y1f32 (_Float32) throw (); extern _Float32 __y1f32 (_Float32) throw (); extern _Float32 ynf32 (int, _Float32) throw (); extern _Float32 __ynf32 (int, _Float32) throw (); extern _Float32 erff32 (_Float32) throw (); extern _Float32 __erff32 (_Float32) throw (); extern _Float32 erfcf32 (_Float32) throw (); extern _Float32 __erfcf32 (_Float32) throw (); extern _Float32 lgammaf32 (_Float32) throw (); extern _Float32 __lgammaf32 (_Float32) throw (); extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw (); # 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32 lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw (); extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw (); extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw (); extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw (); extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw (); extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw (); extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw (); extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern long int lrintf32 (_Float32 __x) throw (); extern long int __lrintf32 (_Float32 __x) throw (); __extension__ extern long long int llrintf32 (_Float32 __x) throw (); extern long long int __llrintf32 (_Float32 __x) throw (); extern long int lroundf32 (_Float32 __x) throw (); extern long int __lroundf32 (_Float32 __x) throw (); __extension__ extern long long int llroundf32 (_Float32 __x) throw (); extern long long int __llroundf32 (_Float32 __x) throw (); extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw () ; extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw (); extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) throw () __attribute__ ((__pure__)); extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) throw () __attribute__ ((__pure__)); extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw (); extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw (); extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) throw (); # 390 "/usr/include/math.h" 2 3 4 # 406 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64 acosf64 (_Float64 __x) throw (); extern _Float64 __acosf64 (_Float64 __x) throw (); extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw (); extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw (); extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw (); extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw (); extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw (); extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw (); extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw (); extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw (); extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw (); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw () ; extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw (); extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw (); extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw (); extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw (); extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw (); extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw (); extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) throw (); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw (); extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw (); extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw (); extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw (); extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw (); extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw (); extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw (); extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw (); extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw (); # 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 nanf64 (const char *__tagb) throw (); extern _Float64 __nanf64 (const char *__tagb) throw (); # 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64 j0f64 (_Float64) throw (); extern _Float64 __j0f64 (_Float64) throw (); extern _Float64 j1f64 (_Float64) throw (); extern _Float64 __j1f64 (_Float64) throw (); extern _Float64 jnf64 (int, _Float64) throw (); extern _Float64 __jnf64 (int, _Float64) throw (); extern _Float64 y0f64 (_Float64) throw (); extern _Float64 __y0f64 (_Float64) throw (); extern _Float64 y1f64 (_Float64) throw (); extern _Float64 __y1f64 (_Float64) throw (); extern _Float64 ynf64 (int, _Float64) throw (); extern _Float64 __ynf64 (int, _Float64) throw (); extern _Float64 erff64 (_Float64) throw (); extern _Float64 __erff64 (_Float64) throw (); extern _Float64 erfcf64 (_Float64) throw (); extern _Float64 __erfcf64 (_Float64) throw (); extern _Float64 lgammaf64 (_Float64) throw (); extern _Float64 __lgammaf64 (_Float64) throw (); extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw (); # 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64 lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw (); extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw (); extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw (); extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw (); extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw (); extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw (); extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw (); extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern long int lrintf64 (_Float64 __x) throw (); extern long int __lrintf64 (_Float64 __x) throw (); __extension__ extern long long int llrintf64 (_Float64 __x) throw (); extern long long int __llrintf64 (_Float64 __x) throw (); extern long int lroundf64 (_Float64 __x) throw (); extern long int __lroundf64 (_Float64 __x) throw (); __extension__ extern long long int llroundf64 (_Float64 __x) throw (); extern long long int __llroundf64 (_Float64 __x) throw (); extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw () ; extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw (); extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) throw () __attribute__ ((__pure__)); extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) throw () __attribute__ ((__pure__)); extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw (); extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw (); extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw (); # 407 "/usr/include/math.h" 2 3 4 # 420 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 1 3 4 # 21 "/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h" 3 4 extern int __fpclassifyf128 (_Float128 __value) throw () __attribute__ ((__const__)); extern int __signbitf128 (_Float128 __value) throw () __attribute__ ((__const__)); extern int __isinff128 (_Float128 __value) throw () __attribute__ ((__const__)); extern int __finitef128 (_Float128 __value) throw () __attribute__ ((__const__)); extern int __isnanf128 (_Float128 __value) throw () __attribute__ ((__const__)); extern int __iseqsigf128 (_Float128 __x, _Float128 __y) throw (); extern int __issignalingf128 (_Float128 __value) throw () __attribute__ ((__const__)); # 421 "/usr/include/math.h" 2 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float128 acosf128 (_Float128 __x) throw (); extern _Float128 __acosf128 (_Float128 __x) throw (); extern _Float128 asinf128 (_Float128 __x) throw (); extern _Float128 __asinf128 (_Float128 __x) throw (); extern _Float128 atanf128 (_Float128 __x) throw (); extern _Float128 __atanf128 (_Float128 __x) throw (); extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) throw (); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) throw (); extern _Float128 cosf128 (_Float128 __x) throw (); extern _Float128 __cosf128 (_Float128 __x) throw (); extern _Float128 sinf128 (_Float128 __x) throw (); extern _Float128 __sinf128 (_Float128 __x) throw (); extern _Float128 tanf128 (_Float128 __x) throw (); extern _Float128 __tanf128 (_Float128 __x) throw (); extern _Float128 coshf128 (_Float128 __x) throw (); extern _Float128 __coshf128 (_Float128 __x) throw (); extern _Float128 sinhf128 (_Float128 __x) throw (); extern _Float128 __sinhf128 (_Float128 __x) throw (); extern _Float128 tanhf128 (_Float128 __x) throw (); extern _Float128 __tanhf128 (_Float128 __x) throw (); extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw (); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw () ; extern _Float128 acoshf128 (_Float128 __x) throw (); extern _Float128 __acoshf128 (_Float128 __x) throw (); extern _Float128 asinhf128 (_Float128 __x) throw (); extern _Float128 __asinhf128 (_Float128 __x) throw (); extern _Float128 atanhf128 (_Float128 __x) throw (); extern _Float128 __atanhf128 (_Float128 __x) throw (); extern _Float128 expf128 (_Float128 __x) throw (); extern _Float128 __expf128 (_Float128 __x) throw (); extern _Float128 frexpf128 (_Float128 __x, int *__exponent) throw (); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) throw (); extern _Float128 ldexpf128 (_Float128 __x, int __exponent) throw (); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) throw (); extern _Float128 logf128 (_Float128 __x) throw (); extern _Float128 __logf128 (_Float128 __x) throw (); extern _Float128 log10f128 (_Float128 __x) throw (); extern _Float128 __log10f128 (_Float128 __x) throw (); extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) throw (); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern _Float128 exp10f128 (_Float128 __x) throw (); extern _Float128 __exp10f128 (_Float128 __x) throw (); extern _Float128 expm1f128 (_Float128 __x) throw (); extern _Float128 __expm1f128 (_Float128 __x) throw (); extern _Float128 log1pf128 (_Float128 __x) throw (); extern _Float128 __log1pf128 (_Float128 __x) throw (); extern _Float128 logbf128 (_Float128 __x) throw (); extern _Float128 __logbf128 (_Float128 __x) throw (); extern _Float128 exp2f128 (_Float128 __x) throw (); extern _Float128 __exp2f128 (_Float128 __x) throw (); extern _Float128 log2f128 (_Float128 __x) throw (); extern _Float128 __log2f128 (_Float128 __x) throw (); extern _Float128 powf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 sqrtf128 (_Float128 __x) throw (); extern _Float128 __sqrtf128 (_Float128 __x) throw (); extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 cbrtf128 (_Float128 __x) throw (); extern _Float128 __cbrtf128 (_Float128 __x) throw (); extern _Float128 ceilf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 fabsf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 floorf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) throw (); # 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 nanf128 (const char *__tagb) throw (); extern _Float128 __nanf128 (const char *__tagb) throw (); # 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float128 j0f128 (_Float128) throw (); extern _Float128 __j0f128 (_Float128) throw (); extern _Float128 j1f128 (_Float128) throw (); extern _Float128 __j1f128 (_Float128) throw (); extern _Float128 jnf128 (int, _Float128) throw (); extern _Float128 __jnf128 (int, _Float128) throw (); extern _Float128 y0f128 (_Float128) throw (); extern _Float128 __y0f128 (_Float128) throw (); extern _Float128 y1f128 (_Float128) throw (); extern _Float128 __y1f128 (_Float128) throw (); extern _Float128 ynf128 (int, _Float128) throw (); extern _Float128 __ynf128 (int, _Float128) throw (); extern _Float128 erff128 (_Float128) throw (); extern _Float128 __erff128 (_Float128) throw (); extern _Float128 erfcf128 (_Float128) throw (); extern _Float128 __erfcf128 (_Float128) throw (); extern _Float128 lgammaf128 (_Float128) throw (); extern _Float128 __lgammaf128 (_Float128) throw (); extern _Float128 tgammaf128 (_Float128) throw (); extern _Float128 __tgammaf128 (_Float128) throw (); # 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float128 lgammaf128_r (_Float128, int *__signgamp) throw (); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) throw (); extern _Float128 rintf128 (_Float128 __x) throw (); extern _Float128 __rintf128 (_Float128 __x) throw (); extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 nextdownf128 (_Float128 __x) throw (); extern _Float128 __nextdownf128 (_Float128 __x) throw (); extern _Float128 nextupf128 (_Float128 __x) throw (); extern _Float128 __nextupf128 (_Float128 __x) throw (); extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 scalbnf128 (_Float128 __x, int __n) throw (); extern _Float128 __scalbnf128 (_Float128 __x, int __n) throw (); extern int ilogbf128 (_Float128 __x) throw (); extern int __ilogbf128 (_Float128 __x) throw (); extern long int llogbf128 (_Float128 __x) throw (); extern long int __llogbf128 (_Float128 __x) throw (); extern _Float128 scalblnf128 (_Float128 __x, long int __n) throw (); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) throw (); extern _Float128 nearbyintf128 (_Float128 __x) throw (); extern _Float128 __nearbyintf128 (_Float128 __x) throw (); extern _Float128 roundf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 truncf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw (); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw (); extern long int lrintf128 (_Float128 __x) throw (); extern long int __lrintf128 (_Float128 __x) throw (); __extension__ extern long long int llrintf128 (_Float128 __x) throw (); extern long long int __llrintf128 (_Float128 __x) throw (); extern long int lroundf128 (_Float128 __x) throw (); extern long int __lroundf128 (_Float128 __x) throw (); __extension__ extern long long int llroundf128 (_Float128 __x) throw (); extern long long int __llroundf128 (_Float128 __x) throw (); extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw (); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw (); extern _Float128 roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw () ; extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) throw (); extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) throw () __attribute__ ((__pure__)); extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) throw () __attribute__ ((__pure__)); extern _Float128 getpayloadf128 (const _Float128 *__x) throw (); extern _Float128 __getpayloadf128 (const _Float128 *__x) throw (); extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) throw (); extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) throw (); # 424 "/usr/include/math.h" 2 3 4 # 440 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32x acosf32x (_Float32x __x) throw (); extern _Float32x __acosf32x (_Float32x __x) throw (); extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw (); extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw (); extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw (); extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw (); extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw (); extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw (); extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw (); extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw (); extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw (); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw () ; extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw (); extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw (); extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw (); extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw (); extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw (); extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw (); extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) throw (); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw (); extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw (); extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw (); extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw (); extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw (); extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw (); extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw (); extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw (); extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw (); # 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x nanf32x (const char *__tagb) throw (); extern _Float32x __nanf32x (const char *__tagb) throw (); # 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32x j0f32x (_Float32x) throw (); extern _Float32x __j0f32x (_Float32x) throw (); extern _Float32x j1f32x (_Float32x) throw (); extern _Float32x __j1f32x (_Float32x) throw (); extern _Float32x jnf32x (int, _Float32x) throw (); extern _Float32x __jnf32x (int, _Float32x) throw (); extern _Float32x y0f32x (_Float32x) throw (); extern _Float32x __y0f32x (_Float32x) throw (); extern _Float32x y1f32x (_Float32x) throw (); extern _Float32x __y1f32x (_Float32x) throw (); extern _Float32x ynf32x (int, _Float32x) throw (); extern _Float32x __ynf32x (int, _Float32x) throw (); extern _Float32x erff32x (_Float32x) throw (); extern _Float32x __erff32x (_Float32x) throw (); extern _Float32x erfcf32x (_Float32x) throw (); extern _Float32x __erfcf32x (_Float32x) throw (); extern _Float32x lgammaf32x (_Float32x) throw (); extern _Float32x __lgammaf32x (_Float32x) throw (); extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw (); # 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw (); extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw (); extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw (); extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw (); extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw (); extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw (); extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw (); extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern long int lrintf32x (_Float32x __x) throw (); extern long int __lrintf32x (_Float32x __x) throw (); __extension__ extern long long int llrintf32x (_Float32x __x) throw (); extern long long int __llrintf32x (_Float32x __x) throw (); extern long int lroundf32x (_Float32x __x) throw (); extern long int __lroundf32x (_Float32x __x) throw (); __extension__ extern long long int llroundf32x (_Float32x __x) throw (); extern long long int __llroundf32x (_Float32x __x) throw (); extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw () ; extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw (); extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) throw () __attribute__ ((__pure__)); extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) throw () __attribute__ ((__pure__)); extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw (); extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw (); extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) throw (); # 441 "/usr/include/math.h" 2 3 4 # 457 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4 # 53 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64x acosf64x (_Float64x __x) throw (); extern _Float64x __acosf64x (_Float64x __x) throw (); extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw (); extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw (); extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw (); extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw (); extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw (); extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw (); extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw (); extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw (); extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw (); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw () ; extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw (); extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw (); extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw (); extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw (); extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw (); extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw (); extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) throw (); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) throw () __attribute__ ((__nonnull__ (2))); extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw (); extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw (); extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw (); extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw (); extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw (); extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw (); extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw (); extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw (); extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw (); # 196 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x nanf64x (const char *__tagb) throw (); extern _Float64x __nanf64x (const char *__tagb) throw (); # 217 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64x j0f64x (_Float64x) throw (); extern _Float64x __j0f64x (_Float64x) throw (); extern _Float64x j1f64x (_Float64x) throw (); extern _Float64x __j1f64x (_Float64x) throw (); extern _Float64x jnf64x (int, _Float64x) throw (); extern _Float64x __jnf64x (int, _Float64x) throw (); extern _Float64x y0f64x (_Float64x) throw (); extern _Float64x __y0f64x (_Float64x) throw (); extern _Float64x y1f64x (_Float64x) throw (); extern _Float64x __y1f64x (_Float64x) throw (); extern _Float64x ynf64x (int, _Float64x) throw (); extern _Float64x __ynf64x (int, _Float64x) throw (); extern _Float64x erff64x (_Float64x) throw (); extern _Float64x __erff64x (_Float64x) throw (); extern _Float64x erfcf64x (_Float64x) throw (); extern _Float64x __erfcf64x (_Float64x) throw (); extern _Float64x lgammaf64x (_Float64x) throw (); extern _Float64x __lgammaf64x (_Float64x) throw (); extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw (); # 249 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4 extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw (); extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw (); extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw (); extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw (); extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw (); extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw (); extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw (); extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern long int lrintf64x (_Float64x __x) throw (); extern long int __lrintf64x (_Float64x __x) throw (); __extension__ extern long long int llrintf64x (_Float64x __x) throw (); extern long long int __llrintf64x (_Float64x __x) throw (); extern long int lroundf64x (_Float64x __x) throw (); extern long int __lroundf64x (_Float64x __x) throw (); __extension__ extern long long int llroundf64x (_Float64x __x) throw (); extern long long int __llroundf64x (_Float64x __x) throw (); extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw () ; extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw () ; extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw () ; extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw (); extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) throw () __attribute__ ((__pure__)); extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) throw () __attribute__ ((__pure__)); extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw (); extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw (); extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw (); # 458 "/usr/include/math.h" 2 3 4 # 503 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern float fadd (double __x, double __y) throw (); extern float fdiv (double __x, double __y) throw (); extern float fmul (double __x, double __y) throw (); extern float fsub (double __x, double __y) throw (); # 504 "/usr/include/math.h" 2 3 4 # 517 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern float faddl (long double __x, long double __y) throw (); extern float fdivl (long double __x, long double __y) throw (); extern float fmull (long double __x, long double __y) throw (); extern float fsubl (long double __x, long double __y) throw (); # 518 "/usr/include/math.h" 2 3 4 # 537 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern double daddl (long double __x, long double __y) throw (); extern double ddivl (long double __x, long double __y) throw (); extern double dmull (long double __x, long double __y) throw (); extern double dsubl (long double __x, long double __y) throw (); # 538 "/usr/include/math.h" 2 3 4 # 616 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) throw (); # 617 "/usr/include/math.h" 2 3 4 # 626 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) throw (); extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) throw (); extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) throw (); extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) throw (); # 627 "/usr/include/math.h" 2 3 4 # 636 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) throw (); extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) throw (); extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) throw (); extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) throw (); # 637 "/usr/include/math.h" 2 3 4 # 646 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) throw (); extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) throw (); extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) throw (); extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) throw (); # 647 "/usr/include/math.h" 2 3 4 # 666 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) throw (); extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) throw (); extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) throw (); extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) throw (); # 667 "/usr/include/math.h" 2 3 4 # 676 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) throw (); extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) throw (); extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) throw (); extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) throw (); # 677 "/usr/include/math.h" 2 3 4 # 686 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) throw (); extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) throw (); extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) throw (); extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) throw (); # 687 "/usr/include/math.h" 2 3 4 # 706 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) throw (); # 707 "/usr/include/math.h" 2 3 4 # 716 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) throw (); extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) throw (); extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) throw (); extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) throw (); # 717 "/usr/include/math.h" 2 3 4 # 736 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 1 3 4 # 24 "/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h" 3 4 extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) throw (); extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) throw (); extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) throw (); extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) throw (); # 737 "/usr/include/math.h" 2 3 4 # 773 "/usr/include/math.h" 3 4 extern int signgam; # 853 "/usr/include/math.h" 3 4 enum { FP_NAN = 0, FP_INFINITE = 1, FP_ZERO = 2, FP_SUBNORMAL = 3, FP_NORMAL = 4 }; # 973 "/usr/include/math.h" 3 4 # 1 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 1 3 4 # 23 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4 extern int __iscanonicall (long double __x) throw () __attribute__ ((__const__)); # 46 "/usr/include/x86_64-linux-gnu/bits/iscanonical.h" 3 4 extern "C++" { inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } inline int iscanonical (long double __val) { return __iscanonicall (__val); } inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); } } # 974 "/usr/include/math.h" 2 3 4 # 985 "/usr/include/math.h" 3 4 extern "C++" { inline int issignaling (float __val) { return __issignalingf (__val); } inline int issignaling (double __val) { return __issignaling (__val); } inline int issignaling (long double __val) { return __issignalingl (__val); } inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); } } # 1016 "/usr/include/math.h" 3 4 extern "C++" { # 1047 "/usr/include/math.h" 3 4 template inline bool iszero (__T __val) { return __val == 0; } } # 1278 "/usr/include/math.h" 3 4 extern "C++" { template struct __iseqsig_type; template<> struct __iseqsig_type { static int __call (float __x, float __y) throw () { return __iseqsigf (__x, __y); } }; template<> struct __iseqsig_type { static int __call (double __x, double __y) throw () { return __iseqsig (__x, __y); } }; template<> struct __iseqsig_type { static int __call (long double __x, long double __y) throw () { return __iseqsigl (__x, __y); } }; template<> struct __iseqsig_type<_Float128> { static int __call (_Float128 __x, _Float128 __y) throw () { return __iseqsigf128 (__x, __y); } }; template inline int iseqsig (_T1 __x, _T2 __y) throw () { typedef decltype (((__x) + (__y) + 0.0f)) _T3; return __iseqsig_type<_T3>::__call (__x, __y); } } } # 46 "/usr/include/c++/10/cmath" 2 3 # 77 "/usr/include/c++/10/cmath" 3 extern "C++" { namespace std __attribute__ ((__visibility__ ("default"))) { using ::acos; inline constexpr float acos(float __x) { return __builtin_acosf(__x); } inline constexpr long double acos(long double __x) { return __builtin_acosl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type acos(_Tp __x) { return __builtin_acos(__x); } using ::asin; inline constexpr float asin(float __x) { return __builtin_asinf(__x); } inline constexpr long double asin(long double __x) { return __builtin_asinl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type asin(_Tp __x) { return __builtin_asin(__x); } using ::atan; inline constexpr float atan(float __x) { return __builtin_atanf(__x); } inline constexpr long double atan(long double __x) { return __builtin_atanl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type atan(_Tp __x) { return __builtin_atan(__x); } using ::atan2; inline constexpr float atan2(float __y, float __x) { return __builtin_atan2f(__y, __x); } inline constexpr long double atan2(long double __y, long double __x) { return __builtin_atan2l(__y, __x); } template inline constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type atan2(_Tp __y, _Up __x) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return atan2(__type(__y), __type(__x)); } using ::ceil; inline constexpr float ceil(float __x) { return __builtin_ceilf(__x); } inline constexpr long double ceil(long double __x) { return __builtin_ceill(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type ceil(_Tp __x) { return __builtin_ceil(__x); } using ::cos; inline constexpr float cos(float __x) { return __builtin_cosf(__x); } inline constexpr long double cos(long double __x) { return __builtin_cosl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type cos(_Tp __x) { return __builtin_cos(__x); } using ::cosh; inline constexpr float cosh(float __x) { return __builtin_coshf(__x); } inline constexpr long double cosh(long double __x) { return __builtin_coshl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type cosh(_Tp __x) { return __builtin_cosh(__x); } using ::exp; inline constexpr float exp(float __x) { return __builtin_expf(__x); } inline constexpr long double exp(long double __x) { return __builtin_expl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type exp(_Tp __x) { return __builtin_exp(__x); } using ::fabs; inline constexpr float fabs(float __x) { return __builtin_fabsf(__x); } inline constexpr long double fabs(long double __x) { return __builtin_fabsl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type fabs(_Tp __x) { return __builtin_fabs(__x); } using ::floor; inline constexpr float floor(float __x) { return __builtin_floorf(__x); } inline constexpr long double floor(long double __x) { return __builtin_floorl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type floor(_Tp __x) { return __builtin_floor(__x); } using ::fmod; inline constexpr float fmod(float __x, float __y) { return __builtin_fmodf(__x, __y); } inline constexpr long double fmod(long double __x, long double __y) { return __builtin_fmodl(__x, __y); } template inline constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmod(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmod(__type(__x), __type(__y)); } using ::frexp; inline float frexp(float __x, int* __exp) { return __builtin_frexpf(__x, __exp); } inline long double frexp(long double __x, int* __exp) { return __builtin_frexpl(__x, __exp); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type frexp(_Tp __x, int* __exp) { return __builtin_frexp(__x, __exp); } using ::ldexp; inline constexpr float ldexp(float __x, int __exp) { return __builtin_ldexpf(__x, __exp); } inline constexpr long double ldexp(long double __x, int __exp) { return __builtin_ldexpl(__x, __exp); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type ldexp(_Tp __x, int __exp) { return __builtin_ldexp(__x, __exp); } using ::log; inline constexpr float log(float __x) { return __builtin_logf(__x); } inline constexpr long double log(long double __x) { return __builtin_logl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log(_Tp __x) { return __builtin_log(__x); } using ::log10; inline constexpr float log10(float __x) { return __builtin_log10f(__x); } inline constexpr long double log10(long double __x) { return __builtin_log10l(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log10(_Tp __x) { return __builtin_log10(__x); } using ::modf; inline float modf(float __x, float* __iptr) { return __builtin_modff(__x, __iptr); } inline long double modf(long double __x, long double* __iptr) { return __builtin_modfl(__x, __iptr); } using ::pow; inline constexpr float pow(float __x, float __y) { return __builtin_powf(__x, __y); } inline constexpr long double pow(long double __x, long double __y) { return __builtin_powl(__x, __y); } # 412 "/usr/include/c++/10/cmath" 3 template inline constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type pow(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return pow(__type(__x), __type(__y)); } using ::sin; inline constexpr float sin(float __x) { return __builtin_sinf(__x); } inline constexpr long double sin(long double __x) { return __builtin_sinl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type sin(_Tp __x) { return __builtin_sin(__x); } using ::sinh; inline constexpr float sinh(float __x) { return __builtin_sinhf(__x); } inline constexpr long double sinh(long double __x) { return __builtin_sinhl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type sinh(_Tp __x) { return __builtin_sinh(__x); } using ::sqrt; inline constexpr float sqrt(float __x) { return __builtin_sqrtf(__x); } inline constexpr long double sqrt(long double __x) { return __builtin_sqrtl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type sqrt(_Tp __x) { return __builtin_sqrt(__x); } using ::tan; inline constexpr float tan(float __x) { return __builtin_tanf(__x); } inline constexpr long double tan(long double __x) { return __builtin_tanl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type tan(_Tp __x) { return __builtin_tan(__x); } using ::tanh; inline constexpr float tanh(float __x) { return __builtin_tanhf(__x); } inline constexpr long double tanh(long double __x) { return __builtin_tanhl(__x); } template inline constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type tanh(_Tp __x) { return __builtin_tanh(__x); } # 536 "/usr/include/c++/10/cmath" 3 constexpr int fpclassify(float __x) { return __builtin_fpclassify(0, 1, 4, 3, 2, __x); } constexpr int fpclassify(double __x) { return __builtin_fpclassify(0, 1, 4, 3, 2, __x); } constexpr int fpclassify(long double __x) { return __builtin_fpclassify(0, 1, 4, 3, 2, __x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, int>::__type fpclassify(_Tp __x) { return __x != 0 ? 4 : 2; } constexpr bool isfinite(float __x) { return __builtin_isfinite(__x); } constexpr bool isfinite(double __x) { return __builtin_isfinite(__x); } constexpr bool isfinite(long double __x) { return __builtin_isfinite(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isfinite(_Tp __x) { return true; } constexpr bool isinf(float __x) { return __builtin_isinf(__x); } constexpr bool isinf(double __x) { return __builtin_isinf(__x); } constexpr bool isinf(long double __x) { return __builtin_isinf(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isinf(_Tp __x) { return false; } constexpr bool isnan(float __x) { return __builtin_isnan(__x); } constexpr bool isnan(double __x) { return __builtin_isnan(__x); } constexpr bool isnan(long double __x) { return __builtin_isnan(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isnan(_Tp __x) { return false; } constexpr bool isnormal(float __x) { return __builtin_isnormal(__x); } constexpr bool isnormal(double __x) { return __builtin_isnormal(__x); } constexpr bool isnormal(long double __x) { return __builtin_isnormal(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type isnormal(_Tp __x) { return __x != 0 ? true : false; } constexpr bool signbit(float __x) { return __builtin_signbit(__x); } constexpr bool signbit(double __x) { return __builtin_signbit(__x); } constexpr bool signbit(long double __x) { return __builtin_signbit(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, bool>::__type signbit(_Tp __x) { return __x < 0 ? true : false; } constexpr bool isgreater(float __x, float __y) { return __builtin_isgreater(__x, __y); } constexpr bool isgreater(double __x, double __y) { return __builtin_isgreater(__x, __y); } constexpr bool isgreater(long double __x, long double __y) { return __builtin_isgreater(__x, __y); } template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isgreater(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isgreater(__type(__x), __type(__y)); } constexpr bool isgreaterequal(float __x, float __y) { return __builtin_isgreaterequal(__x, __y); } constexpr bool isgreaterequal(double __x, double __y) { return __builtin_isgreaterequal(__x, __y); } constexpr bool isgreaterequal(long double __x, long double __y) { return __builtin_isgreaterequal(__x, __y); } template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isgreaterequal(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isgreaterequal(__type(__x), __type(__y)); } constexpr bool isless(float __x, float __y) { return __builtin_isless(__x, __y); } constexpr bool isless(double __x, double __y) { return __builtin_isless(__x, __y); } constexpr bool isless(long double __x, long double __y) { return __builtin_isless(__x, __y); } template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isless(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isless(__type(__x), __type(__y)); } constexpr bool islessequal(float __x, float __y) { return __builtin_islessequal(__x, __y); } constexpr bool islessequal(double __x, double __y) { return __builtin_islessequal(__x, __y); } constexpr bool islessequal(long double __x, long double __y) { return __builtin_islessequal(__x, __y); } template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type islessequal(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_islessequal(__type(__x), __type(__y)); } constexpr bool islessgreater(float __x, float __y) { return __builtin_islessgreater(__x, __y); } constexpr bool islessgreater(double __x, double __y) { return __builtin_islessgreater(__x, __y); } constexpr bool islessgreater(long double __x, long double __y) { return __builtin_islessgreater(__x, __y); } template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type islessgreater(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_islessgreater(__type(__x), __type(__y)); } constexpr bool isunordered(float __x, float __y) { return __builtin_isunordered(__x, __y); } constexpr bool isunordered(double __x, double __y) { return __builtin_isunordered(__x, __y); } constexpr bool isunordered(long double __x, long double __y) { return __builtin_isunordered(__x, __y); } template constexpr typename __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value && __is_arithmetic<_Up>::__value), bool>::__type isunordered(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return __builtin_isunordered(__type(__x), __type(__y)); } # 1065 "/usr/include/c++/10/cmath" 3 using ::double_t; using ::float_t; using ::acosh; using ::acoshf; using ::acoshl; using ::asinh; using ::asinhf; using ::asinhl; using ::atanh; using ::atanhf; using ::atanhl; using ::cbrt; using ::cbrtf; using ::cbrtl; using ::copysign; using ::copysignf; using ::copysignl; using ::erf; using ::erff; using ::erfl; using ::erfc; using ::erfcf; using ::erfcl; using ::exp2; using ::exp2f; using ::exp2l; using ::expm1; using ::expm1f; using ::expm1l; using ::fdim; using ::fdimf; using ::fdiml; using ::fma; using ::fmaf; using ::fmal; using ::fmax; using ::fmaxf; using ::fmaxl; using ::fmin; using ::fminf; using ::fminl; using ::hypot; using ::hypotf; using ::hypotl; using ::ilogb; using ::ilogbf; using ::ilogbl; using ::lgamma; using ::lgammaf; using ::lgammal; using ::llrint; using ::llrintf; using ::llrintl; using ::llround; using ::llroundf; using ::llroundl; using ::log1p; using ::log1pf; using ::log1pl; using ::log2; using ::log2f; using ::log2l; using ::logb; using ::logbf; using ::logbl; using ::lrint; using ::lrintf; using ::lrintl; using ::lround; using ::lroundf; using ::lroundl; using ::nan; using ::nanf; using ::nanl; using ::nearbyint; using ::nearbyintf; using ::nearbyintl; using ::nextafter; using ::nextafterf; using ::nextafterl; using ::nexttoward; using ::nexttowardf; using ::nexttowardl; using ::remainder; using ::remainderf; using ::remainderl; using ::remquo; using ::remquof; using ::remquol; using ::rint; using ::rintf; using ::rintl; using ::round; using ::roundf; using ::roundl; using ::scalbln; using ::scalblnf; using ::scalblnl; using ::scalbn; using ::scalbnf; using ::scalbnl; using ::tgamma; using ::tgammaf; using ::tgammal; using ::trunc; using ::truncf; using ::truncl; constexpr float acosh(float __x) { return __builtin_acoshf(__x); } constexpr long double acosh(long double __x) { return __builtin_acoshl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type acosh(_Tp __x) { return __builtin_acosh(__x); } constexpr float asinh(float __x) { return __builtin_asinhf(__x); } constexpr long double asinh(long double __x) { return __builtin_asinhl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type asinh(_Tp __x) { return __builtin_asinh(__x); } constexpr float atanh(float __x) { return __builtin_atanhf(__x); } constexpr long double atanh(long double __x) { return __builtin_atanhl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type atanh(_Tp __x) { return __builtin_atanh(__x); } constexpr float cbrt(float __x) { return __builtin_cbrtf(__x); } constexpr long double cbrt(long double __x) { return __builtin_cbrtl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type cbrt(_Tp __x) { return __builtin_cbrt(__x); } constexpr float copysign(float __x, float __y) { return __builtin_copysignf(__x, __y); } constexpr long double copysign(long double __x, long double __y) { return __builtin_copysignl(__x, __y); } template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type copysign(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return copysign(__type(__x), __type(__y)); } constexpr float erf(float __x) { return __builtin_erff(__x); } constexpr long double erf(long double __x) { return __builtin_erfl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type erf(_Tp __x) { return __builtin_erf(__x); } constexpr float erfc(float __x) { return __builtin_erfcf(__x); } constexpr long double erfc(long double __x) { return __builtin_erfcl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type erfc(_Tp __x) { return __builtin_erfc(__x); } constexpr float exp2(float __x) { return __builtin_exp2f(__x); } constexpr long double exp2(long double __x) { return __builtin_exp2l(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type exp2(_Tp __x) { return __builtin_exp2(__x); } constexpr float expm1(float __x) { return __builtin_expm1f(__x); } constexpr long double expm1(long double __x) { return __builtin_expm1l(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type expm1(_Tp __x) { return __builtin_expm1(__x); } constexpr float fdim(float __x, float __y) { return __builtin_fdimf(__x, __y); } constexpr long double fdim(long double __x, long double __y) { return __builtin_fdiml(__x, __y); } template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fdim(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fdim(__type(__x), __type(__y)); } constexpr float fma(float __x, float __y, float __z) { return __builtin_fmaf(__x, __y, __z); } constexpr long double fma(long double __x, long double __y, long double __z) { return __builtin_fmal(__x, __y, __z); } template constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type fma(_Tp __x, _Up __y, _Vp __z) { typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; return fma(__type(__x), __type(__y), __type(__z)); } constexpr float fmax(float __x, float __y) { return __builtin_fmaxf(__x, __y); } constexpr long double fmax(long double __x, long double __y) { return __builtin_fmaxl(__x, __y); } template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmax(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmax(__type(__x), __type(__y)); } constexpr float fmin(float __x, float __y) { return __builtin_fminf(__x, __y); } constexpr long double fmin(long double __x, long double __y) { return __builtin_fminl(__x, __y); } template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type fmin(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return fmin(__type(__x), __type(__y)); } constexpr float hypot(float __x, float __y) { return __builtin_hypotf(__x, __y); } constexpr long double hypot(long double __x, long double __y) { return __builtin_hypotl(__x, __y); } template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type hypot(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return hypot(__type(__x), __type(__y)); } constexpr int ilogb(float __x) { return __builtin_ilogbf(__x); } constexpr int ilogb(long double __x) { return __builtin_ilogbl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, int>::__type ilogb(_Tp __x) { return __builtin_ilogb(__x); } constexpr float lgamma(float __x) { return __builtin_lgammaf(__x); } constexpr long double lgamma(long double __x) { return __builtin_lgammal(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type lgamma(_Tp __x) { return __builtin_lgamma(__x); } constexpr long long llrint(float __x) { return __builtin_llrintf(__x); } constexpr long long llrint(long double __x) { return __builtin_llrintl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long long>::__type llrint(_Tp __x) { return __builtin_llrint(__x); } constexpr long long llround(float __x) { return __builtin_llroundf(__x); } constexpr long long llround(long double __x) { return __builtin_llroundl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long long>::__type llround(_Tp __x) { return __builtin_llround(__x); } constexpr float log1p(float __x) { return __builtin_log1pf(__x); } constexpr long double log1p(long double __x) { return __builtin_log1pl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log1p(_Tp __x) { return __builtin_log1p(__x); } constexpr float log2(float __x) { return __builtin_log2f(__x); } constexpr long double log2(long double __x) { return __builtin_log2l(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type log2(_Tp __x) { return __builtin_log2(__x); } constexpr float logb(float __x) { return __builtin_logbf(__x); } constexpr long double logb(long double __x) { return __builtin_logbl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type logb(_Tp __x) { return __builtin_logb(__x); } constexpr long lrint(float __x) { return __builtin_lrintf(__x); } constexpr long lrint(long double __x) { return __builtin_lrintl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long>::__type lrint(_Tp __x) { return __builtin_lrint(__x); } constexpr long lround(float __x) { return __builtin_lroundf(__x); } constexpr long lround(long double __x) { return __builtin_lroundl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, long>::__type lround(_Tp __x) { return __builtin_lround(__x); } constexpr float nearbyint(float __x) { return __builtin_nearbyintf(__x); } constexpr long double nearbyint(long double __x) { return __builtin_nearbyintl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type nearbyint(_Tp __x) { return __builtin_nearbyint(__x); } constexpr float nextafter(float __x, float __y) { return __builtin_nextafterf(__x, __y); } constexpr long double nextafter(long double __x, long double __y) { return __builtin_nextafterl(__x, __y); } template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type nextafter(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return nextafter(__type(__x), __type(__y)); } constexpr float nexttoward(float __x, long double __y) { return __builtin_nexttowardf(__x, __y); } constexpr long double nexttoward(long double __x, long double __y) { return __builtin_nexttowardl(__x, __y); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type nexttoward(_Tp __x, long double __y) { return __builtin_nexttoward(__x, __y); } constexpr float remainder(float __x, float __y) { return __builtin_remainderf(__x, __y); } constexpr long double remainder(long double __x, long double __y) { return __builtin_remainderl(__x, __y); } template constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type remainder(_Tp __x, _Up __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return remainder(__type(__x), __type(__y)); } inline float remquo(float __x, float __y, int* __pquo) { return __builtin_remquof(__x, __y, __pquo); } inline long double remquo(long double __x, long double __y, int* __pquo) { return __builtin_remquol(__x, __y, __pquo); } template inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type remquo(_Tp __x, _Up __y, int* __pquo) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return remquo(__type(__x), __type(__y), __pquo); } constexpr float rint(float __x) { return __builtin_rintf(__x); } constexpr long double rint(long double __x) { return __builtin_rintl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type rint(_Tp __x) { return __builtin_rint(__x); } constexpr float round(float __x) { return __builtin_roundf(__x); } constexpr long double round(long double __x) { return __builtin_roundl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type round(_Tp __x) { return __builtin_round(__x); } constexpr float scalbln(float __x, long __ex) { return __builtin_scalblnf(__x, __ex); } constexpr long double scalbln(long double __x, long __ex) { return __builtin_scalblnl(__x, __ex); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type scalbln(_Tp __x, long __ex) { return __builtin_scalbln(__x, __ex); } constexpr float scalbn(float __x, int __ex) { return __builtin_scalbnf(__x, __ex); } constexpr long double scalbn(long double __x, int __ex) { return __builtin_scalbnl(__x, __ex); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type scalbn(_Tp __x, int __ex) { return __builtin_scalbn(__x, __ex); } constexpr float tgamma(float __x) { return __builtin_tgammaf(__x); } constexpr long double tgamma(long double __x) { return __builtin_tgammal(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type tgamma(_Tp __x) { return __builtin_tgamma(__x); } constexpr float trunc(float __x) { return __builtin_truncf(__x); } constexpr long double trunc(long double __x) { return __builtin_truncl(__x); } template constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, double>::__type trunc(_Tp __x) { return __builtin_trunc(__x); } # 1852 "/usr/include/c++/10/cmath" 3 template inline _Tp __hypot3(_Tp __x, _Tp __y, _Tp __z) { __x = std::abs(__x); __y = std::abs(__y); __z = std::abs(__z); if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) return __a * std::sqrt((__x / __a) * (__x / __a) + (__y / __a) * (__y / __a) + (__z / __a) * (__z / __a)); else return {}; } inline float hypot(float __x, float __y, float __z) { return std::__hypot3(__x, __y, __z); } inline double hypot(double __x, double __y, double __z) { return std::__hypot3(__x, __y, __z); } inline long double hypot(long double __x, long double __y, long double __z) { return std::__hypot3(__x, __y, __z); } template typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type hypot(_Tp __x, _Up __y, _Vp __z) { using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type; return std::__hypot3<__type>(__x, __y, __z); } template constexpr _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept { if (__a <= 0 && __b >= 0 || __a >= 0 && __b <= 0) return __t * __b + (1 - __t) * __a; if (__t == 1) return __b; const _Fp __x = __a + __t * (__b - __a); return __t > 1 == __b > __a ? (__b < __x ? __x : __b) : (__b > __x ? __x : __b); } constexpr float lerp(float __a, float __b, float __t) noexcept { return std::__lerp(__a, __b, __t); } constexpr double lerp(double __a, double __b, double __t) noexcept { return std::__lerp(__a, __b, __t); } constexpr long double lerp(long double __a, long double __b, long double __t) noexcept { return std::__lerp(__a, __b, __t); } } # 1 "/usr/include/c++/10/bits/specfun.h" 1 3 # 33 "/usr/include/c++/10/bits/specfun.h" 3 #pragma GCC visibility push(default) # 49 "/usr/include/c++/10/bits/specfun.h" 3 # 1 "/usr/include/c++/10/tr1/gamma.tcc" 1 3 # 49 "/usr/include/c++/10/tr1/gamma.tcc" 3 # 1 "/usr/include/c++/10/tr1/special_function_util.h" 1 3 # 39 "/usr/include/c++/10/tr1/special_function_util.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 50 "/usr/include/c++/10/tr1/special_function_util.h" 3 namespace __detail { template struct __floating_point_constant { static const _Tp __value; }; template struct __numeric_constants { static _Tp __pi() throw() { return static_cast<_Tp>(3.1415926535897932384626433832795029L); } static _Tp __pi_2() throw() { return static_cast<_Tp>(1.5707963267948966192313216916397514L); } static _Tp __pi_3() throw() { return static_cast<_Tp>(1.0471975511965977461542144610931676L); } static _Tp __pi_4() throw() { return static_cast<_Tp>(0.7853981633974483096156608458198757L); } static _Tp __1_pi() throw() { return static_cast<_Tp>(0.3183098861837906715377675267450287L); } static _Tp __2_sqrtpi() throw() { return static_cast<_Tp>(1.1283791670955125738961589031215452L); } static _Tp __sqrt2() throw() { return static_cast<_Tp>(1.4142135623730950488016887242096981L); } static _Tp __sqrt3() throw() { return static_cast<_Tp>(1.7320508075688772935274463415058723L); } static _Tp __sqrtpio2() throw() { return static_cast<_Tp>(1.2533141373155002512078826424055226L); } static _Tp __sqrt1_2() throw() { return static_cast<_Tp>(0.7071067811865475244008443621048490L); } static _Tp __lnpi() throw() { return static_cast<_Tp>(1.1447298858494001741434273513530587L); } static _Tp __gamma_e() throw() { return static_cast<_Tp>(0.5772156649015328606065120900824024L); } static _Tp __euler() throw() { return static_cast<_Tp>(2.7182818284590452353602874713526625L); } }; # 114 "/usr/include/c++/10/tr1/special_function_util.h" 3 template inline bool __isnan(_Tp __x) { return std::isnan(__x); } # 133 "/usr/include/c++/10/tr1/special_function_util.h" 3 } } # 50 "/usr/include/c++/10/tr1/gamma.tcc" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 65 "/usr/include/c++/10/tr1/gamma.tcc" 3 namespace __detail { # 76 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __bernoulli_series(unsigned int __n) { static const _Tp __num[28] = { _Tp(1UL), -_Tp(1UL) / _Tp(2UL), _Tp(1UL) / _Tp(6UL), _Tp(0UL), -_Tp(1UL) / _Tp(30UL), _Tp(0UL), _Tp(1UL) / _Tp(42UL), _Tp(0UL), -_Tp(1UL) / _Tp(30UL), _Tp(0UL), _Tp(5UL) / _Tp(66UL), _Tp(0UL), -_Tp(691UL) / _Tp(2730UL), _Tp(0UL), _Tp(7UL) / _Tp(6UL), _Tp(0UL), -_Tp(3617UL) / _Tp(510UL), _Tp(0UL), _Tp(43867UL) / _Tp(798UL), _Tp(0UL), -_Tp(174611) / _Tp(330UL), _Tp(0UL), _Tp(854513UL) / _Tp(138UL), _Tp(0UL), -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL), _Tp(8553103UL) / _Tp(6UL), _Tp(0UL) }; if (__n == 0) return _Tp(1); if (__n == 1) return -_Tp(1) / _Tp(2); if (__n % 2 == 1) return _Tp(0); if (__n < 28) return __num[__n]; _Tp __fact = _Tp(1); if ((__n / 2) % 2 == 0) __fact *= _Tp(-1); for (unsigned int __k = 1; __k <= __n; ++__k) __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi()); __fact *= _Tp(2); _Tp __sum = _Tp(0); for (unsigned int __i = 1; __i < 1000; ++__i) { _Tp __term = std::pow(_Tp(__i), -_Tp(__n)); if (__term < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term; } return __fact * __sum; } # 139 "/usr/include/c++/10/tr1/gamma.tcc" 3 template inline _Tp __bernoulli(int __n) { return __bernoulli_series<_Tp>(__n); } # 153 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __log_gamma_bernoulli(_Tp __x) { _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x + _Tp(0.5L) * std::log(_Tp(2) * __numeric_constants<_Tp>::__pi()); const _Tp __xx = __x * __x; _Tp __help = _Tp(1) / __x; for ( unsigned int __i = 1; __i < 20; ++__i ) { const _Tp __2i = _Tp(2 * __i); __help /= __2i * (__2i - _Tp(1)) * __xx; __lg += __bernoulli<_Tp>(2 * __i) * __help; } return __lg; } # 181 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __log_gamma_lanczos(_Tp __x) { const _Tp __xm1 = __x - _Tp(1); static const _Tp __lanczos_cheb_7[9] = { _Tp( 0.99999999999980993227684700473478L), _Tp( 676.520368121885098567009190444019L), _Tp(-1259.13921672240287047156078755283L), _Tp( 771.3234287776530788486528258894L), _Tp(-176.61502916214059906584551354L), _Tp( 12.507343278686904814458936853L), _Tp(-0.13857109526572011689554707L), _Tp( 9.984369578019570859563e-6L), _Tp( 1.50563273514931155834e-7L) }; static const _Tp __LOGROOT2PI = _Tp(0.9189385332046727417803297364056176L); _Tp __sum = __lanczos_cheb_7[0]; for(unsigned int __k = 1; __k < 9; ++__k) __sum += __lanczos_cheb_7[__k] / (__xm1 + __k); const _Tp __term1 = (__xm1 + _Tp(0.5L)) * std::log((__xm1 + _Tp(7.5L)) / __numeric_constants<_Tp>::__euler()); const _Tp __term2 = __LOGROOT2PI + std::log(__sum); const _Tp __result = __term1 + (__term2 - _Tp(7)); return __result; } # 225 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __log_gamma(_Tp __x) { if (__x > _Tp(0.5L)) return __log_gamma_lanczos(__x); else { const _Tp __sin_fact = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x)); if (__sin_fact == _Tp(0)) std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma") ); return __numeric_constants<_Tp>::__lnpi() - std::log(__sin_fact) - __log_gamma_lanczos(_Tp(1) - __x); } } # 252 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __log_gamma_sign(_Tp __x) { if (__x > _Tp(0)) return _Tp(1); else { const _Tp __sin_fact = std::sin(__numeric_constants<_Tp>::__pi() * __x); if (__sin_fact > _Tp(0)) return (1); else if (__sin_fact < _Tp(0)) return -_Tp(1); else return _Tp(0); } } # 283 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __log_bincoef(unsigned int __n, unsigned int __k) { static const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); _Tp __coeff = ::std::lgamma(_Tp(1 + __n)) - ::std::lgamma(_Tp(1 + __k)) - ::std::lgamma(_Tp(1 + __n - __k)); } # 314 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __bincoef(unsigned int __n, unsigned int __k) { static const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k); if (__log_coeff > __max_bincoeff) return std::numeric_limits<_Tp>::quiet_NaN(); else return std::exp(__log_coeff); } # 337 "/usr/include/c++/10/tr1/gamma.tcc" 3 template inline _Tp __gamma(_Tp __x) { return std::exp(__log_gamma(__x)); } # 356 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __psi_series(_Tp __x) { _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x; const unsigned int __max_iter = 100000; for (unsigned int __k = 1; __k < __max_iter; ++__k) { const _Tp __term = __x / (__k * (__k + __x)); __sum += __term; if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) break; } return __sum; } # 386 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __psi_asymp(_Tp __x) { _Tp __sum = std::log(__x) - _Tp(0.5L) / __x; const _Tp __xx = __x * __x; _Tp __xp = __xx; const unsigned int __max_iter = 100; for (unsigned int __k = 1; __k < __max_iter; ++__k) { const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp); __sum -= __term; if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon()) break; __xp *= __xx; } return __sum; } # 417 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __psi(_Tp __x) { const int __n = static_cast(__x + 0.5L); const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon(); if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x < _Tp(0)) { const _Tp __pi = __numeric_constants<_Tp>::__pi(); return __psi(_Tp(1) - __x) - __pi * std::cos(__pi * __x) / std::sin(__pi * __x); } else if (__x > _Tp(100)) return __psi_asymp(__x); else return __psi_series(__x); } # 446 "/usr/include/c++/10/tr1/gamma.tcc" 3 template _Tp __psi(unsigned int __n, _Tp __x) { if (__x <= _Tp(0)) std::__throw_domain_error(("Argument out of range " "in __psi") ); else if (__n == 0) return __psi(__x); else { const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x); const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1)); _Tp __result = std::exp(__ln_nfact) * __hzeta; if (__n % 2 == 1) __result = -__result; return __result; } } } } # 50 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/bessel_function.tcc" 1 3 # 55 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 71 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 namespace __detail { # 98 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template void __gamma_temme(_Tp __mu, _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi) { __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu); __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu); if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon()) __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e()); else __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu); __gam2 = (__gammi + __gampl) / (_Tp(2)); return; } # 136 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template void __bessel_jn(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu) { if (__x == _Tp(0)) { if (__nu == _Tp(0)) { __Jnu = _Tp(1); __Jpnu = _Tp(0); } else if (__nu == _Tp(1)) { __Jnu = _Tp(0); __Jpnu = _Tp(0.5L); } else { __Jnu = _Tp(0); __Jpnu = _Tp(0); } __Nnu = -std::numeric_limits<_Tp>::infinity(); __Npnu = std::numeric_limits<_Tp>::infinity(); return; } const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min()); const int __max_iter = 15000; const _Tp __x_min = _Tp(2); const int __nl = (__x < __x_min ? static_cast(__nu + _Tp(0.5L)) : std::max(0, static_cast(__nu - __x + _Tp(1.5L)))); const _Tp __mu = __nu - __nl; const _Tp __mu2 = __mu * __mu; const _Tp __xi = _Tp(1) / __x; const _Tp __xi2 = _Tp(2) * __xi; _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi(); int __isign = 1; _Tp __h = __nu * __xi; if (__h < __fp_min) __h = __fp_min; _Tp __b = __xi2 * __nu; _Tp __d = _Tp(0); _Tp __c = __h; int __i; for (__i = 1; __i <= __max_iter; ++__i) { __b += __xi2; __d = __b - __d; if (std::abs(__d) < __fp_min) __d = __fp_min; __c = __b - _Tp(1) / __c; if (std::abs(__c) < __fp_min) __c = __fp_min; __d = _Tp(1) / __d; const _Tp __del = __c * __d; __h *= __del; if (__d < _Tp(0)) __isign = -__isign; if (std::abs(__del - _Tp(1)) < __eps) break; } if (__i > __max_iter) std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.") ); _Tp __Jnul = __isign * __fp_min; _Tp __Jpnul = __h * __Jnul; _Tp __Jnul1 = __Jnul; _Tp __Jpnu1 = __Jpnul; _Tp __fact = __nu * __xi; for ( int __l = __nl; __l >= 1; --__l ) { const _Tp __Jnutemp = __fact * __Jnul + __Jpnul; __fact -= __xi; __Jpnul = __fact * __Jnutemp - __Jnul; __Jnul = __Jnutemp; } if (__Jnul == _Tp(0)) __Jnul = __eps; _Tp __f= __Jpnul / __Jnul; _Tp __Nmu, __Nnu1, __Npmu, __Jmu; if (__x < __x_min) { const _Tp __x2 = __x / _Tp(2); const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; _Tp __fact = (std::abs(__pimu) < __eps ? _Tp(1) : __pimu / std::sin(__pimu)); _Tp __d = -std::log(__x2); _Tp __e = __mu * __d; _Tp __fact2 = (std::abs(__e) < __eps ? _Tp(1) : std::sinh(__e) / __e); _Tp __gam1, __gam2, __gampl, __gammi; __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi()) * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); __e = std::exp(__e); _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl); _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi); const _Tp __pimu2 = __pimu / _Tp(2); _Tp __fact3 = (std::abs(__pimu2) < __eps ? _Tp(1) : std::sin(__pimu2) / __pimu2 ); _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3; _Tp __c = _Tp(1); __d = -__x2 * __x2; _Tp __sum = __ff + __r * __q; _Tp __sum1 = __p; for (__i = 1; __i <= __max_iter; ++__i) { __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); __c *= __d / _Tp(__i); __p /= _Tp(__i) - __mu; __q /= _Tp(__i) + __mu; const _Tp __del = __c * (__ff + __r * __q); __sum += __del; const _Tp __del1 = __c * __p - __i * __del; __sum1 += __del1; if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) ) break; } if ( __i > __max_iter ) std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.") ); __Nmu = -__sum; __Nnu1 = -__sum1 * __xi2; __Npmu = __mu * __xi * __Nmu - __Nnu1; __Jmu = __w / (__Npmu - __f * __Nmu); } else { _Tp __a = _Tp(0.25L) - __mu2; _Tp __q = _Tp(1); _Tp __p = -__xi / _Tp(2); _Tp __br = _Tp(2) * __x; _Tp __bi = _Tp(2); _Tp __fact = __a * __xi / (__p * __p + __q * __q); _Tp __cr = __br + __q * __fact; _Tp __ci = __bi + __p * __fact; _Tp __den = __br * __br + __bi * __bi; _Tp __dr = __br / __den; _Tp __di = -__bi / __den; _Tp __dlr = __cr * __dr - __ci * __di; _Tp __dli = __cr * __di + __ci * __dr; _Tp __temp = __p * __dlr - __q * __dli; __q = __p * __dli + __q * __dlr; __p = __temp; int __i; for (__i = 2; __i <= __max_iter; ++__i) { __a += _Tp(2 * (__i - 1)); __bi += _Tp(2); __dr = __a * __dr + __br; __di = __a * __di + __bi; if (std::abs(__dr) + std::abs(__di) < __fp_min) __dr = __fp_min; __fact = __a / (__cr * __cr + __ci * __ci); __cr = __br + __cr * __fact; __ci = __bi - __ci * __fact; if (std::abs(__cr) + std::abs(__ci) < __fp_min) __cr = __fp_min; __den = __dr * __dr + __di * __di; __dr /= __den; __di /= -__den; __dlr = __cr * __dr - __ci * __di; __dli = __cr * __di + __ci * __dr; __temp = __p * __dlr - __q * __dli; __q = __p * __dli + __q * __dlr; __p = __temp; if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps) break; } if (__i > __max_iter) std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.") ); const _Tp __gam = (__p - __f) / __q; __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q)); __Jmu = ::std::copysign(__Jmu, __Jnul); __Nmu = __gam * __Jmu; __Npmu = (__p + __q / __gam) * __Nmu; __Nnu1 = __mu * __xi * __Nmu - __Npmu; } __fact = __Jmu / __Jnul; __Jnu = __fact * __Jnul1; __Jpnu = __fact * __Jpnu1; for (__i = 1; __i <= __nl; ++__i) { const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu; __Nmu = __Nnu1; __Nnu1 = __Nnutemp; } __Nnu = __Nmu; __Npnu = __nu * __xi * __Nmu - __Nnu1; return; } # 361 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template void __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu) { const _Tp __mu = _Tp(4) * __nu * __nu; const _Tp __8x = _Tp(8) * __x; _Tp __P = _Tp(0); _Tp __Q = _Tp(0); _Tp __k = _Tp(0); _Tp __term = _Tp(1); int __epsP = 0; int __epsQ = 0; _Tp __eps = std::numeric_limits<_Tp>::epsilon(); do { __term *= (__k == 0 ? _Tp(1) : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x)); __epsP = std::abs(__term) < __eps * std::abs(__P); __P += __term; __k++; __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x); __epsQ = std::abs(__term) < __eps * std::abs(__Q); __Q += __term; if (__epsP && __epsQ && __k > (__nu / 2.)) break; __k++; } while (__k < 1000); const _Tp __chi = __x - (__nu + _Tp(0.5L)) * __numeric_constants<_Tp>::__pi_2(); const _Tp __c = std::cos(__chi); const _Tp __s = std::sin(__chi); const _Tp __coef = std::sqrt(_Tp(2) / (__numeric_constants<_Tp>::__pi() * __x)); __Jnu = __coef * (__c * __P - __s * __Q); __Nnu = __coef * (__s * __P + __c * __Q); return; } # 444 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template _Tp __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn, unsigned int __max_iter) { if (__x == _Tp(0)) return __nu == _Tp(0) ? _Tp(1) : _Tp(0); const _Tp __x2 = __x / _Tp(2); _Tp __fact = __nu * std::log(__x2); __fact -= ::std::lgamma(__nu + _Tp(1)); __fact = std::exp(__fact); const _Tp __xx4 = __sgn * __x2 * __x2; _Tp __Jn = _Tp(1); _Tp __term = _Tp(1); for (unsigned int __i = 1; __i < __max_iter; ++__i) { __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i))); __Jn += __term; if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon()) break; } return __fact * __Jn; } # 490 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template _Tp __cyl_bessel_j(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.") ); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200); else if (__x > _Tp(1000)) { _Tp __J_nu, __N_nu; __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); return __J_nu; } else { _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); return __J_nu; } } # 532 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template _Tp __cyl_neumann_n(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.") ); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x > _Tp(1000)) { _Tp __J_nu, __N_nu; __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu); return __N_nu; } else { _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); return __N_nu; } } # 569 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template void __sph_bessel_jn(unsigned int __n, _Tp __x, _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n) { const _Tp __nu = _Tp(__n) + _Tp(0.5L); _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu; __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu); const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() / std::sqrt(__x); __j_n = __factor * __J_nu; __n_n = __factor * __N_nu; __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x); __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x); return; } # 604 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template _Tp __sph_bessel(unsigned int __n, _Tp __x) { if (__x < _Tp(0)) std::__throw_domain_error(("Bad argument " "in __sph_bessel.") ); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x == _Tp(0)) { if (__n == 0) return _Tp(1); else return _Tp(0); } else { _Tp __j_n, __n_n, __jp_n, __np_n; __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); return __j_n; } } # 642 "/usr/include/c++/10/tr1/bessel_function.tcc" 3 template _Tp __sph_neumann(unsigned int __n, _Tp __x) { if (__x < _Tp(0)) std::__throw_domain_error(("Bad argument " "in __sph_neumann.") ); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x == _Tp(0)) return -std::numeric_limits<_Tp>::infinity(); else { _Tp __j_n, __n_n, __jp_n, __np_n; __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n); return __n_n; } } } } # 51 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/beta_function.tcc" 1 3 # 49 "/usr/include/c++/10/tr1/beta_function.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 65 "/usr/include/c++/10/tr1/beta_function.tcc" 3 namespace __detail { # 79 "/usr/include/c++/10/tr1/beta_function.tcc" 3 template _Tp __beta_gamma(_Tp __x, _Tp __y) { _Tp __bet; if (__x > __y) { __bet = ::std::tgamma(__x) / ::std::tgamma(__x + __y); __bet *= ::std::tgamma(__y); } else { __bet = ::std::tgamma(__y) / ::std::tgamma(__x + __y); __bet *= ::std::tgamma(__x); } # 111 "/usr/include/c++/10/tr1/beta_function.tcc" 3 return __bet; } # 127 "/usr/include/c++/10/tr1/beta_function.tcc" 3 template _Tp __beta_lgamma(_Tp __x, _Tp __y) { _Tp __bet = ::std::lgamma(__x) + ::std::lgamma(__y) - ::std::lgamma(__x + __y); __bet = std::exp(__bet); return __bet; } # 158 "/usr/include/c++/10/tr1/beta_function.tcc" 3 template _Tp __beta_product(_Tp __x, _Tp __y) { _Tp __bet = (__x + __y) / (__x * __y); unsigned int __max_iter = 1000000; for (unsigned int __k = 1; __k < __max_iter; ++__k) { _Tp __term = (_Tp(1) + (__x + __y) / __k) / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k)); __bet *= __term; } return __bet; } # 189 "/usr/include/c++/10/tr1/beta_function.tcc" 3 template inline _Tp __beta(_Tp __x, _Tp __y) { if (__isnan(__x) || __isnan(__y)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __beta_lgamma(__x, __y); } } } # 52 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/ell_integral.tcc" 1 3 # 45 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 59 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 namespace __detail { # 76 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __ellint_rf(_Tp __x, _Tp __y, _Tp __z) { const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = _Tp(5) * __min; const _Tp __uplim = __max / _Tp(5); if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.") ); else if (__x + __y < __lolim || __x + __z < __lolim || __y + __z < __lolim) std::__throw_domain_error(("Argument too small in __ellint_rf")); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(1) / _Tp(24); const _Tp __c2 = _Tp(1) / _Tp(10); const _Tp __c3 = _Tp(3) / _Tp(44); const _Tp __c4 = _Tp(1) / _Tp(14); _Tp __xn = __x; _Tp __yn = __y; _Tp __zn = __z; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6)); _Tp __mu; _Tp __xndev, __yndev, __zndev; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + __yn + __zn) / _Tp(3); __xndev = 2 - (__mu + __xn) / __mu; __yndev = 2 - (__mu + __yn) / __mu; __zndev = 2 - (__mu + __zn) / __mu; _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); __epsilon = std::max(__epsilon, std::abs(__zndev)); if (__epsilon < __errtol) break; const _Tp __xnroot = std::sqrt(__xn); const _Tp __ynroot = std::sqrt(__yn); const _Tp __znroot = std::sqrt(__zn); const _Tp __lambda = __xnroot * (__ynroot + __znroot) + __ynroot * __znroot; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); __zn = __c0 * (__zn + __lambda); } const _Tp __e2 = __xndev * __yndev - __zndev * __zndev; const _Tp __e3 = __xndev * __yndev * __zndev; const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2 + __c4 * __e3; return __s / std::sqrt(__mu); } } # 155 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __comp_ellint_1_series(_Tp __k) { const _Tp __kk = __k * __k; _Tp __term = __kk / _Tp(4); _Tp __sum = _Tp(1) + __term; const unsigned int __max_iter = 1000; for (unsigned int __i = 2; __i < __max_iter; ++__i) { __term *= (2 * __i - 1) * __kk / (2 * __i); if (__term < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term; } return __numeric_constants<_Tp>::__pi_2() * __sum; } # 193 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __comp_ellint_1(_Tp __k) { if (__isnan(__k)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) >= _Tp(1)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1)); } # 221 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __ellint_1(_Tp __k, _Tp __phi) { if (__isnan(__k) || __isnan(__phi)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(("Bad argument in __ellint_1.")); else { const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + _Tp(0.5L)); const _Tp __phi_red = __phi - __n * __numeric_constants<_Tp>::__pi(); const _Tp __s = std::sin(__phi_red); const _Tp __c = std::cos(__phi_red); const _Tp __F = __s * __ellint_rf(__c * __c, _Tp(1) - __k * __k * __s * __s, _Tp(1)); if (__n == 0) return __F; else return __F + _Tp(2) * __n * __comp_ellint_1(__k); } } # 268 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __comp_ellint_2_series(_Tp __k) { const _Tp __kk = __k * __k; _Tp __term = __kk; _Tp __sum = __term; const unsigned int __max_iter = 1000; for (unsigned int __i = 2; __i < __max_iter; ++__i) { const _Tp __i2m = 2 * __i - 1; const _Tp __i2 = 2 * __i; __term *= __i2m * __i2m * __kk / (__i2 * __i2); if (__term < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term / __i2m; } return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum); } # 316 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __ellint_rd(_Tp __x, _Tp __y, _Tp __z) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3)); const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3)); if (__x < _Tp(0) || __y < _Tp(0)) std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.") ); else if (__x + __y < __lolim || __z < __lolim) std::__throw_domain_error(("Argument too small " "in __ellint_rd.") ); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(3) / _Tp(14); const _Tp __c2 = _Tp(1) / _Tp(6); const _Tp __c3 = _Tp(9) / _Tp(22); const _Tp __c4 = _Tp(3) / _Tp(26); _Tp __xn = __x; _Tp __yn = __y; _Tp __zn = __z; _Tp __sigma = _Tp(0); _Tp __power4 = _Tp(1); _Tp __mu; _Tp __xndev, __yndev, __zndev; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5); __xndev = (__mu - __xn) / __mu; __yndev = (__mu - __yn) / __mu; __zndev = (__mu - __zn) / __mu; _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); __epsilon = std::max(__epsilon, std::abs(__zndev)); if (__epsilon < __errtol) break; _Tp __xnroot = std::sqrt(__xn); _Tp __ynroot = std::sqrt(__yn); _Tp __znroot = std::sqrt(__zn); _Tp __lambda = __xnroot * (__ynroot + __znroot) + __ynroot * __znroot; __sigma += __power4 / (__znroot * (__zn + __lambda)); __power4 *= __c0; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); __zn = __c0 * (__zn + __lambda); } _Tp __ea = __xndev * __yndev; _Tp __eb = __zndev * __zndev; _Tp __ec = __ea - __eb; _Tp __ed = __ea - _Tp(6) * __eb; _Tp __ef = __ed + __ec + __ec; _Tp __s1 = __ed * (-__c1 + __c3 * __ed / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef / _Tp(2)); _Tp __s2 = __zndev * (__c2 * __ef + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea)); return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2) / (__mu * std::sqrt(__mu)); } } # 403 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __comp_ellint_2(_Tp __k) { if (__isnan(__k)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) == 1) return _Tp(1); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(("Bad argument in __comp_ellint_2.")); else { const _Tp __kk = __k * __k; return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3); } } # 437 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __ellint_2(_Tp __k, _Tp __phi) { if (__isnan(__k) || __isnan(__phi)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(("Bad argument in __ellint_2.")); else { const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + _Tp(0.5L)); const _Tp __phi_red = __phi - __n * __numeric_constants<_Tp>::__pi(); const _Tp __kk = __k * __k; const _Tp __s = std::sin(__phi_red); const _Tp __ss = __s * __s; const _Tp __sss = __ss * __s; const _Tp __c = std::cos(__phi_red); const _Tp __cc = __c * __c; const _Tp __E = __s * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) - __kk * __sss * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1)) / _Tp(3); if (__n == 0) return __E; else return __E + _Tp(2) * __n * __comp_ellint_2(__k); } } # 496 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __ellint_rc(_Tp __x, _Tp __y) { const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = _Tp(5) * __min; const _Tp __uplim = __max / _Tp(5); if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim) std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.") ); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(1) / _Tp(7); const _Tp __c2 = _Tp(9) / _Tp(22); const _Tp __c3 = _Tp(3) / _Tp(10); const _Tp __c4 = _Tp(3) / _Tp(8); _Tp __xn = __x; _Tp __yn = __y; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6)); _Tp __mu; _Tp __sn; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + _Tp(2) * __yn) / _Tp(3); __sn = (__yn + __mu) / __mu - _Tp(2); if (std::abs(__sn) < __errtol) break; const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn) + __yn; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); } _Tp __s = __sn * __sn * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2))); return (_Tp(1) + __s) / std::sqrt(__mu); } } # 567 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p) { const _Tp __min = std::numeric_limits<_Tp>::min(); const _Tp __max = std::numeric_limits<_Tp>::max(); const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3)); const _Tp __uplim = _Tp(0.3L) * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3)); if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0)) std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.") ); else if (__x + __y < __lolim || __x + __z < __lolim || __y + __z < __lolim || __p < __lolim) std::__throw_domain_error(("Argument too small " "in __ellint_rj") ); else { const _Tp __c0 = _Tp(1) / _Tp(4); const _Tp __c1 = _Tp(3) / _Tp(14); const _Tp __c2 = _Tp(1) / _Tp(3); const _Tp __c3 = _Tp(3) / _Tp(22); const _Tp __c4 = _Tp(3) / _Tp(26); _Tp __xn = __x; _Tp __yn = __y; _Tp __zn = __z; _Tp __pn = __p; _Tp __sigma = _Tp(0); _Tp __power4 = _Tp(1); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6)); _Tp __lambda, __mu; _Tp __xndev, __yndev, __zndev, __pndev; const unsigned int __max_iter = 100; for (unsigned int __iter = 0; __iter < __max_iter; ++__iter) { __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5); __xndev = (__mu - __xn) / __mu; __yndev = (__mu - __yn) / __mu; __zndev = (__mu - __zn) / __mu; __pndev = (__mu - __pn) / __mu; _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev)); __epsilon = std::max(__epsilon, std::abs(__zndev)); __epsilon = std::max(__epsilon, std::abs(__pndev)); if (__epsilon < __errtol) break; const _Tp __xnroot = std::sqrt(__xn); const _Tp __ynroot = std::sqrt(__yn); const _Tp __znroot = std::sqrt(__zn); const _Tp __lambda = __xnroot * (__ynroot + __znroot) + __ynroot * __znroot; const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot) + __xnroot * __ynroot * __znroot; const _Tp __alpha2 = __alpha1 * __alpha1; const _Tp __beta = __pn * (__pn + __lambda) * (__pn + __lambda); __sigma += __power4 * __ellint_rc(__alpha2, __beta); __power4 *= __c0; __xn = __c0 * (__xn + __lambda); __yn = __c0 * (__yn + __lambda); __zn = __c0 * (__zn + __lambda); __pn = __c0 * (__pn + __lambda); } _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev; _Tp __eb = __xndev * __yndev * __zndev; _Tp __ec = __pndev * __pndev; _Tp __e2 = __ea - _Tp(3) * __ec; _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec); _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4) - _Tp(3) * __c4 * __e3 / _Tp(2)); _Tp __s2 = __eb * (__c2 / _Tp(2) + __pndev * (-__c3 - __c3 + __pndev * __c4)); _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3) - __c2 * __pndev * __ec; return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3) / (__mu * std::sqrt(__mu)); } } # 670 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __comp_ellint_3(_Tp __k, _Tp __nu) { if (__isnan(__k) || __isnan(__nu)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__nu == _Tp(1)) return std::numeric_limits<_Tp>::infinity(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(("Bad argument in __comp_ellint_3.")); else { const _Tp __kk = __k * __k; return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1)) + __nu * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu) / _Tp(3); } } # 710 "/usr/include/c++/10/tr1/ell_integral.tcc" 3 template _Tp __ellint_3(_Tp __k, _Tp __nu, _Tp __phi) { if (__isnan(__k) || __isnan(__nu) || __isnan(__phi)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (std::abs(__k) > _Tp(1)) std::__throw_domain_error(("Bad argument in __ellint_3.")); else { const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi() + _Tp(0.5L)); const _Tp __phi_red = __phi - __n * __numeric_constants<_Tp>::__pi(); const _Tp __kk = __k * __k; const _Tp __s = std::sin(__phi_red); const _Tp __ss = __s * __s; const _Tp __sss = __ss * __s; const _Tp __c = std::cos(__phi_red); const _Tp __cc = __c * __c; const _Tp __Pi = __s * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1)) + __nu * __sss * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1), _Tp(1) - __nu * __ss) / _Tp(3); if (__n == 0) return __Pi; else return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu); } } } } # 53 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/exp_integral.tcc" 1 3 # 50 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 64 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 namespace __detail { template _Tp __expint_E1(_Tp); # 81 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_E1_series(_Tp __x) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); _Tp __term = _Tp(1); _Tp __esum = _Tp(0); _Tp __osum = _Tp(0); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { __term *= - __x / __i; if (std::abs(__term) < __eps) break; if (__term >= _Tp(0)) __esum += __term / __i; else __osum += __term / __i; } return - __esum - __osum - __numeric_constants<_Tp>::__gamma_e() - std::log(__x); } # 118 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_E1_asymp(_Tp __x) { _Tp __term = _Tp(1); _Tp __esum = _Tp(1); _Tp __osum = _Tp(0); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { _Tp __prev = __term; __term *= - __i / __x; if (std::abs(__term) > std::abs(__prev)) break; if (__term >= _Tp(0)) __esum += __term; else __osum += __term; } return std::exp(- __x) * (__esum + __osum) / __x; } # 155 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_En_series(unsigned int __n, _Tp __x) { const unsigned int __max_iter = 1000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const int __nm1 = __n - 1; _Tp __ans = (__nm1 != 0 ? _Tp(1) / __nm1 : -std::log(__x) - __numeric_constants<_Tp>::__gamma_e()); _Tp __fact = _Tp(1); for (int __i = 1; __i <= __max_iter; ++__i) { __fact *= -__x / _Tp(__i); _Tp __del; if ( __i != __nm1 ) __del = -__fact / _Tp(__i - __nm1); else { _Tp __psi = -__numeric_constants<_Tp>::gamma_e(); for (int __ii = 1; __ii <= __nm1; ++__ii) __psi += _Tp(1) / _Tp(__ii); __del = __fact * (__psi - std::log(__x)); } __ans += __del; if (std::abs(__del) < __eps * std::abs(__ans)) return __ans; } std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.") ); } # 201 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_En_cont_frac(unsigned int __n, _Tp __x) { const unsigned int __max_iter = 1000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __fp_min = std::numeric_limits<_Tp>::min(); const int __nm1 = __n - 1; _Tp __b = __x + _Tp(__n); _Tp __c = _Tp(1) / __fp_min; _Tp __d = _Tp(1) / __b; _Tp __h = __d; for ( unsigned int __i = 1; __i <= __max_iter; ++__i ) { _Tp __a = -_Tp(__i * (__nm1 + __i)); __b += _Tp(2); __d = _Tp(1) / (__a * __d + __b); __c = __b + __a / __c; const _Tp __del = __c * __d; __h *= __del; if (std::abs(__del - _Tp(1)) < __eps) { const _Tp __ans = __h * std::exp(-__x); return __ans; } } std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.") ); } # 246 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_En_recursion(unsigned int __n, _Tp __x) { _Tp __En; _Tp __E1 = __expint_E1(__x); if (__x < _Tp(__n)) { __En = __E1; for (unsigned int __j = 2; __j < __n; ++__j) __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1); } else { __En = _Tp(1); const int __N = __n + 20; _Tp __save = _Tp(0); for (int __j = __N; __j > 0; --__j) { __En = (std::exp(-__x) - __j * __En) / __x; if (__j == __n) __save = __En; } _Tp __norm = __En / __E1; __En /= __norm; } return __En; } # 290 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_Ei_series(_Tp __x) { _Tp __term = _Tp(1); _Tp __sum = _Tp(0); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { __term *= __x / __i; __sum += __term / __i; if (__term < std::numeric_limits<_Tp>::epsilon() * __sum) break; } return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x); } # 321 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_Ei_asymp(_Tp __x) { _Tp __term = _Tp(1); _Tp __sum = _Tp(1); const unsigned int __max_iter = 1000; for (unsigned int __i = 1; __i < __max_iter; ++__i) { _Tp __prev = __term; __term *= __i / __x; if (__term < std::numeric_limits<_Tp>::epsilon()) break; if (__term >= __prev) break; __sum += __term; } return std::exp(__x) * __sum / __x; } # 354 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_Ei(_Tp __x) { if (__x < _Tp(0)) return -__expint_E1(-__x); else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon())) return __expint_Ei_series(__x); else return __expint_Ei_asymp(__x); } # 378 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_E1(_Tp __x) { if (__x < _Tp(0)) return -__expint_Ei(-__x); else if (__x < _Tp(1)) return __expint_E1_series(__x); else if (__x < _Tp(100)) return __expint_En_cont_frac(1, __x); else return __expint_E1_asymp(__x); } # 408 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_asymp(unsigned int __n, _Tp __x) { _Tp __term = _Tp(1); _Tp __sum = _Tp(1); for (unsigned int __i = 1; __i <= __n; ++__i) { _Tp __prev = __term; __term *= -(__n - __i + 1) / __x; if (std::abs(__term) > std::abs(__prev)) break; __sum += __term; } return std::exp(-__x) * __sum / __x; } # 442 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint_large_n(unsigned int __n, _Tp __x) { const _Tp __xpn = __x + __n; const _Tp __xpn2 = __xpn * __xpn; _Tp __term = _Tp(1); _Tp __sum = _Tp(1); for (unsigned int __i = 1; __i <= __n; ++__i) { _Tp __prev = __term; __term *= (__n - 2 * (__i - 1) * __x) / __xpn2; if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) break; __sum += __term; } return std::exp(-__x) * __sum / __xpn; } # 476 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template _Tp __expint(unsigned int __n, _Tp __x) { if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__n <= 1 && __x == _Tp(0)) return std::numeric_limits<_Tp>::infinity(); else { _Tp __E0 = std::exp(__x) / __x; if (__n == 0) return __E0; _Tp __E1 = __expint_E1(__x); if (__n == 1) return __E1; if (__x == _Tp(0)) return _Tp(1) / static_cast<_Tp>(__n - 1); _Tp __En = __expint_En_recursion(__n, __x); return __En; } } # 516 "/usr/include/c++/10/tr1/exp_integral.tcc" 3 template inline _Tp __expint(_Tp __x) { if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __expint_Ei(__x); } } } # 54 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/hypergeometric.tcc" 1 3 # 44 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 60 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 namespace __detail { # 83 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 template _Tp __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); _Tp __term = _Tp(1); _Tp __Fac = _Tp(1); const unsigned int __max_iter = 100000; unsigned int __i; for (__i = 0; __i < __max_iter; ++__i) { __term *= (__a + _Tp(__i)) * __x / ((__c + _Tp(__i)) * _Tp(1 + __i)); if (std::abs(__term) < __eps) { break; } __Fac += __term; } if (__i == __max_iter) std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.") ); return __Fac; } # 120 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 template _Tp __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin) { const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); const int __nmax = 20000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __x = -__xin; const _Tp __x3 = __x * __x * __x; const _Tp __t0 = __a / __c; const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c); const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); _Tp __F = _Tp(1); _Tp __prec; _Tp __Bnm3 = _Tp(1); _Tp __Bnm2 = _Tp(1) + __t1 * __x; _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); _Tp __Anm3 = _Tp(1); _Tp __Anm2 = __Bnm2 - __t0 * __x; _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; int __n = 3; while(1) { _Tp __npam1 = _Tp(__n - 1) + __a; _Tp __npcm1 = _Tp(__n - 1) + __c; _Tp __npam2 = _Tp(__n - 2) + __a; _Tp __npcm2 = _Tp(__n - 2) + __c; _Tp __tnm1 = _Tp(2 * __n - 1); _Tp __tnm3 = _Tp(2 * __n - 3); _Tp __tnm5 = _Tp(2 * __n - 5); _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1); _Tp __F2 = (_Tp(__n) + __a) * __npam1 / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a) / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); _Tp __E = -__npam1 * (_Tp(__n - 1) - __c) / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; _Tp __r = __An / __Bn; __prec = std::abs((__F - __r) / __F); __F = __r; if (__prec < __eps || __n > __nmax) break; if (std::abs(__An) > __big || std::abs(__Bn) > __big) { __An /= __big; __Bn /= __big; __Anm1 /= __big; __Bnm1 /= __big; __Anm2 /= __big; __Bnm2 /= __big; __Anm3 /= __big; __Bnm3 /= __big; } else if (std::abs(__An) < _Tp(1) / __big || std::abs(__Bn) < _Tp(1) / __big) { __An *= __big; __Bn *= __big; __Anm1 *= __big; __Bnm1 *= __big; __Anm2 *= __big; __Bnm2 *= __big; __Anm3 *= __big; __Bnm3 *= __big; } ++__n; __Bnm3 = __Bnm2; __Bnm2 = __Bnm1; __Bnm1 = __Bn; __Anm3 = __Anm2; __Anm2 = __Anm1; __Anm1 = __An; } if (__n >= __nmax) std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.") ); return __F; } # 227 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 template _Tp __conf_hyperg(_Tp __a, _Tp __c, _Tp __x) { const _Tp __c_nint = ::std::nearbyint(__c); if (__isnan(__a) || __isnan(__c) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__c_nint == __c && __c_nint <= 0) return std::numeric_limits<_Tp>::infinity(); else if (__a == _Tp(0)) return _Tp(1); else if (__c == __a) return std::exp(__x); else if (__x < _Tp(0)) return __conf_hyperg_luke(__a, __c, __x); else return __conf_hyperg_series(__a, __c, __x); } # 271 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 template _Tp __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x) { const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); _Tp __term = _Tp(1); _Tp __Fabc = _Tp(1); const unsigned int __max_iter = 100000; unsigned int __i; for (__i = 0; __i < __max_iter; ++__i) { __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x / ((__c + _Tp(__i)) * _Tp(1 + __i)); if (std::abs(__term) < __eps) { break; } __Fabc += __term; } if (__i == __max_iter) std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.") ); return __Fabc; } template _Tp __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin) { const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L)); const int __nmax = 20000; const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __x = -__xin; const _Tp __x3 = __x * __x * __x; const _Tp __t0 = __a * __b / __c; const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c); const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2)) / (_Tp(2) * (__c + _Tp(1))); _Tp __F = _Tp(1); _Tp __Bnm3 = _Tp(1); _Tp __Bnm2 = _Tp(1) + __t1 * __x; _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x); _Tp __Anm3 = _Tp(1); _Tp __Anm2 = __Bnm2 - __t0 * __x; _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x; int __n = 3; while (1) { const _Tp __npam1 = _Tp(__n - 1) + __a; const _Tp __npbm1 = _Tp(__n - 1) + __b; const _Tp __npcm1 = _Tp(__n - 1) + __c; const _Tp __npam2 = _Tp(__n - 2) + __a; const _Tp __npbm2 = _Tp(__n - 2) + __b; const _Tp __npcm2 = _Tp(__n - 2) + __c; const _Tp __tnm1 = _Tp(2 * __n - 1); const _Tp __tnm3 = _Tp(2 * __n - 3); const _Tp __tnm5 = _Tp(2 * __n - 5); const _Tp __n2 = __n * __n; const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n + _Tp(2) - __a * __b - _Tp(2) * (__a + __b)) / (_Tp(2) * __tnm3 * __npcm1); const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n + _Tp(2) - __a * __b) * __npam1 * __npbm1 / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1); const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1 * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b)) / (_Tp(8) * __tnm3 * __tnm3 * __tnm5 * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1); const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c) / (_Tp(2) * __tnm3 * __npcm2 * __npcm1); _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1 + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3; _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1 + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3; const _Tp __r = __An / __Bn; const _Tp __prec = std::abs((__F - __r) / __F); __F = __r; if (__prec < __eps || __n > __nmax) break; if (std::abs(__An) > __big || std::abs(__Bn) > __big) { __An /= __big; __Bn /= __big; __Anm1 /= __big; __Bnm1 /= __big; __Anm2 /= __big; __Bnm2 /= __big; __Anm3 /= __big; __Bnm3 /= __big; } else if (std::abs(__An) < _Tp(1) / __big || std::abs(__Bn) < _Tp(1) / __big) { __An *= __big; __Bn *= __big; __Anm1 *= __big; __Bnm1 *= __big; __Anm2 *= __big; __Bnm2 *= __big; __Anm3 *= __big; __Bnm3 *= __big; } ++__n; __Bnm3 = __Bnm2; __Bnm2 = __Bnm1; __Bnm1 = __Bn; __Anm3 = __Anm2; __Anm2 = __Anm1; __Anm1 = __An; } if (__n >= __nmax) std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.") ); return __F; } # 438 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 template _Tp __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x) { const _Tp __d = __c - __a - __b; const int __intd = std::floor(__d + _Tp(0.5L)); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __toler = _Tp(1000) * __eps; const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max()); const bool __d_integer = (std::abs(__d - __intd) < __toler); if (__d_integer) { const _Tp __ln_omx = std::log(_Tp(1) - __x); const _Tp __ad = std::abs(__d); _Tp __F1, __F2; _Tp __d1, __d2; if (__d >= _Tp(0)) { __d1 = __d; __d2 = _Tp(0); } else { __d1 = _Tp(0); __d2 = __d; } const _Tp __lng_c = __log_gamma(__c); if (__ad < __eps) { __F1 = _Tp(0); } else { bool __ok_d1 = true; _Tp __lng_ad, __lng_ad1, __lng_bd1; try { __lng_ad = __log_gamma(__ad); __lng_ad1 = __log_gamma(__a + __d1); __lng_bd1 = __log_gamma(__b + __d1); } catch(...) { __ok_d1 = false; } if (__ok_d1) { _Tp __sum1 = _Tp(1); _Tp __term = _Tp(1); _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx - __lng_ad1 - __lng_bd1; for (int __i = 1; __i < __ad; ++__i) { const int __j = __i - 1; __term *= (__a + __d2 + __j) * (__b + __d2 + __j) / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x); __sum1 += __term; } if (__ln_pre1 > __log_max) std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.") ); else __F1 = std::exp(__ln_pre1) * __sum1; } else { __F1 = _Tp(0); } } bool __ok_d2 = true; _Tp __lng_ad2, __lng_bd2; try { __lng_ad2 = __log_gamma(__a + __d2); __lng_bd2 = __log_gamma(__b + __d2); } catch(...) { __ok_d2 = false; } if (__ok_d2) { const int __maxiter = 2000; const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e(); const _Tp __psi_1pd = __psi(_Tp(1) + __ad); const _Tp __psi_apd1 = __psi(__a + __d1); const _Tp __psi_bpd1 = __psi(__b + __d1); _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1 - __psi_bpd1 - __ln_omx; _Tp __fact = _Tp(1); _Tp __sum2 = __psi_term; _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx - __lng_ad2 - __lng_bd2; int __j; for (__j = 1; __j < __maxiter; ++__j) { const _Tp __term1 = _Tp(1) / _Tp(__j) + _Tp(1) / (__ad + __j); const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1)) + _Tp(1) / (__b + __d1 + _Tp(__j - 1)); __psi_term += __term1 - __term2; __fact *= (__a + __d1 + _Tp(__j - 1)) * (__b + __d1 + _Tp(__j - 1)) / ((__ad + __j) * __j) * (_Tp(1) - __x); const _Tp __delta = __fact * __psi_term; __sum2 += __delta; if (std::abs(__delta) < __eps * std::abs(__sum2)) break; } if (__j == __maxiter) std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect") ); if (__sum2 == _Tp(0)) __F2 = _Tp(0); else __F2 = std::exp(__ln_pre2) * __sum2; } else { __F2 = _Tp(0); } const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1)); const _Tp __F = __F1 + __sgn_2 * __F2; return __F; } else { bool __ok1 = true; _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0); _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0); try { __sgn_g1ca = __log_gamma_sign(__c - __a); __ln_g1ca = __log_gamma(__c - __a); __sgn_g1cb = __log_gamma_sign(__c - __b); __ln_g1cb = __log_gamma(__c - __b); } catch(...) { __ok1 = false; } bool __ok2 = true; _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0); _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0); try { __sgn_g2a = __log_gamma_sign(__a); __ln_g2a = __log_gamma(__a); __sgn_g2b = __log_gamma_sign(__b); __ln_g2b = __log_gamma(__b); } catch(...) { __ok2 = false; } const _Tp __sgn_gc = __log_gamma_sign(__c); const _Tp __ln_gc = __log_gamma(__c); const _Tp __sgn_gd = __log_gamma_sign(__d); const _Tp __ln_gd = __log_gamma(__d); const _Tp __sgn_gmd = __log_gamma_sign(-__d); const _Tp __ln_gmd = __log_gamma(-__d); const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb; const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b; _Tp __pre1, __pre2; if (__ok1 && __ok2) { _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + __d * std::log(_Tp(1) - __x); if (__ln_pre1 < __log_max && __ln_pre2 < __log_max) { __pre1 = std::exp(__ln_pre1); __pre2 = std::exp(__ln_pre2); __pre1 *= __sgn1; __pre2 *= __sgn2; } else { std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") ); } } else if (__ok1 && !__ok2) { _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb; if (__ln_pre1 < __log_max) { __pre1 = std::exp(__ln_pre1); __pre1 *= __sgn1; __pre2 = _Tp(0); } else { std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") ); } } else if (!__ok1 && __ok2) { _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b + __d * std::log(_Tp(1) - __x); if (__ln_pre2 < __log_max) { __pre1 = _Tp(0); __pre2 = std::exp(__ln_pre2); __pre2 *= __sgn2; } else { std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect") ); } } else { __pre1 = _Tp(0); __pre2 = _Tp(0); std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect") ); } const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d, _Tp(1) - __x); const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d, _Tp(1) - __x); const _Tp __F = __pre1 * __F1 + __pre2 * __F2; return __F; } } # 728 "/usr/include/c++/10/tr1/hypergeometric.tcc" 3 template _Tp __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x) { const _Tp __a_nint = ::std::nearbyint(__a); const _Tp __b_nint = ::std::nearbyint(__b); const _Tp __c_nint = ::std::nearbyint(__c); const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon(); if (std::abs(__x) >= _Tp(1)) std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.") ); else if (__isnan(__a) || __isnan(__b) || __isnan(__c) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__c_nint == __c && __c_nint <= _Tp(0)) return std::numeric_limits<_Tp>::infinity(); else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler) return std::pow(_Tp(1) - __x, __c - __a - __b); else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0) && __x >= _Tp(0) && __x < _Tp(0.995L)) return __hyperg_series(__a, __b, __c, __x); else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10)) { if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler) return __hyperg_series(__a_nint, __b, __c, __x); else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler) return __hyperg_series(__a, __b_nint, __c, __x); else if (__x < -_Tp(0.25L)) return __hyperg_luke(__a, __b, __c, __x); else if (__x < _Tp(0.5L)) return __hyperg_series(__a, __b, __c, __x); else if (std::abs(__c) > _Tp(10)) return __hyperg_series(__a, __b, __c, __x); else return __hyperg_reflect(__a, __b, __c, __x); } else return __hyperg_luke(__a, __b, __c, __x); } } } # 55 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/legendre_function.tcc" 1 3 # 49 "/usr/include/c++/10/tr1/legendre_function.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 65 "/usr/include/c++/10/tr1/legendre_function.tcc" 3 namespace __detail { # 80 "/usr/include/c++/10/tr1/legendre_function.tcc" 3 template _Tp __poly_legendre_p(unsigned int __l, _Tp __x) { if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x == +_Tp(1)) return +_Tp(1); else if (__x == -_Tp(1)) return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1)); else { _Tp __p_lm2 = _Tp(1); if (__l == 0) return __p_lm2; _Tp __p_lm1 = __x; if (__l == 1) return __p_lm1; _Tp __p_l = 0; for (unsigned int __ll = 2; __ll <= __l; ++__ll) { __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2 - (__x * __p_lm1 - __p_lm2) / _Tp(__ll); __p_lm2 = __p_lm1; __p_lm1 = __p_l; } return __p_l; } } # 136 "/usr/include/c++/10/tr1/legendre_function.tcc" 3 template _Tp __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x, _Tp __phase = _Tp(+1)) { if (__m > __l) return _Tp(0); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__m == 0) return __poly_legendre_p(__l, __x); else { _Tp __p_mm = _Tp(1); if (__m > 0) { _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x); _Tp __fact = _Tp(1); for (unsigned int __i = 1; __i <= __m; ++__i) { __p_mm *= __phase * __fact * __root; __fact += _Tp(2); } } if (__l == __m) return __p_mm; _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm; if (__l == __m + 1) return __p_mp1m; _Tp __p_lm2m = __p_mm; _Tp __P_lm1m = __p_mp1m; _Tp __p_lm = _Tp(0); for (unsigned int __j = __m + 2; __j <= __l; ++__j) { __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m); __p_lm2m = __P_lm1m; __P_lm1m = __p_lm; } return __p_lm; } } # 214 "/usr/include/c++/10/tr1/legendre_function.tcc" 3 template _Tp __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) { if (__isnan(__theta)) return std::numeric_limits<_Tp>::quiet_NaN(); const _Tp __x = std::cos(__theta); if (__m > __l) return _Tp(0); else if (__m == 0) { _Tp __P = __poly_legendre_p(__l, __x); _Tp __fact = std::sqrt(_Tp(2 * __l + 1) / (_Tp(4) * __numeric_constants<_Tp>::__pi())); __P *= __fact; return __P; } else if (__x == _Tp(1) || __x == -_Tp(1)) { return _Tp(0); } else { const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1)); const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3)); const _Tp __lncirc = ::std::log1p(-__x * __x); const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L))) - ::std::lgamma(_Tp(__m)); const _Tp __lnpre_val = -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi() + _Tp(0.5L) * (__lnpoch + __m * __lncirc); const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m) / (_Tp(4) * __numeric_constants<_Tp>::__pi())); _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val); _Tp __y_mp1m = __y_mp1m_factor * __y_mm; if (__l == __m) return __y_mm; else if (__l == __m + 1) return __y_mp1m; else { _Tp __y_lm = _Tp(0); for (unsigned int __ll = __m + 2; __ll <= __l; ++__ll) { const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m); const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1); const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1) * _Tp(2 * __ll - 1)); const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1) / _Tp(2 * __ll - 3)); __y_lm = (__x * __y_mp1m * __fact1 - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m); __y_mm = __y_mp1m; __y_mp1m = __y_lm; } return __y_lm; } } } } } # 56 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 1 3 # 51 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 65 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3 namespace __detail { # 83 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3 template void __bessel_ik(_Tp __nu, _Tp __x, _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu) { if (__x == _Tp(0)) { if (__nu == _Tp(0)) { __Inu = _Tp(1); __Ipnu = _Tp(0); } else if (__nu == _Tp(1)) { __Inu = _Tp(0); __Ipnu = _Tp(0.5L); } else { __Inu = _Tp(0); __Ipnu = _Tp(0); } __Knu = std::numeric_limits<_Tp>::infinity(); __Kpnu = -std::numeric_limits<_Tp>::infinity(); return; } const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon(); const int __max_iter = 15000; const _Tp __x_min = _Tp(2); const int __nl = static_cast(__nu + _Tp(0.5L)); const _Tp __mu = __nu - __nl; const _Tp __mu2 = __mu * __mu; const _Tp __xi = _Tp(1) / __x; const _Tp __xi2 = _Tp(2) * __xi; _Tp __h = __nu * __xi; if ( __h < __fp_min ) __h = __fp_min; _Tp __b = __xi2 * __nu; _Tp __d = _Tp(0); _Tp __c = __h; int __i; for ( __i = 1; __i <= __max_iter; ++__i ) { __b += __xi2; __d = _Tp(1) / (__b + __d); __c = __b + _Tp(1) / __c; const _Tp __del = __c * __d; __h *= __del; if (std::abs(__del - _Tp(1)) < __eps) break; } if (__i > __max_iter) std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.") ); _Tp __Inul = __fp_min; _Tp __Ipnul = __h * __Inul; _Tp __Inul1 = __Inul; _Tp __Ipnu1 = __Ipnul; _Tp __fact = __nu * __xi; for (int __l = __nl; __l >= 1; --__l) { const _Tp __Inutemp = __fact * __Inul + __Ipnul; __fact -= __xi; __Ipnul = __fact * __Inutemp + __Inul; __Inul = __Inutemp; } _Tp __f = __Ipnul / __Inul; _Tp __Kmu, __Knu1; if (__x < __x_min) { const _Tp __x2 = __x / _Tp(2); const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu; const _Tp __fact = (std::abs(__pimu) < __eps ? _Tp(1) : __pimu / std::sin(__pimu)); _Tp __d = -std::log(__x2); _Tp __e = __mu * __d; const _Tp __fact2 = (std::abs(__e) < __eps ? _Tp(1) : std::sinh(__e) / __e); _Tp __gam1, __gam2, __gampl, __gammi; __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi); _Tp __ff = __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d); _Tp __sum = __ff; __e = std::exp(__e); _Tp __p = __e / (_Tp(2) * __gampl); _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi); _Tp __c = _Tp(1); __d = __x2 * __x2; _Tp __sum1 = __p; int __i; for (__i = 1; __i <= __max_iter; ++__i) { __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2); __c *= __d / __i; __p /= __i - __mu; __q /= __i + __mu; const _Tp __del = __c * __ff; __sum += __del; const _Tp __del1 = __c * (__p - __i * __ff); __sum1 += __del1; if (std::abs(__del) < __eps * std::abs(__sum)) break; } if (__i > __max_iter) std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.") ); __Kmu = __sum; __Knu1 = __sum1 * __xi2; } else { _Tp __b = _Tp(2) * (_Tp(1) + __x); _Tp __d = _Tp(1) / __b; _Tp __delh = __d; _Tp __h = __delh; _Tp __q1 = _Tp(0); _Tp __q2 = _Tp(1); _Tp __a1 = _Tp(0.25L) - __mu2; _Tp __q = __c = __a1; _Tp __a = -__a1; _Tp __s = _Tp(1) + __q * __delh; int __i; for (__i = 2; __i <= __max_iter; ++__i) { __a -= 2 * (__i - 1); __c = -__a * __c / __i; const _Tp __qnew = (__q1 - __b * __q2) / __a; __q1 = __q2; __q2 = __qnew; __q += __c * __qnew; __b += _Tp(2); __d = _Tp(1) / (__b + __a * __d); __delh = (__b * __d - _Tp(1)) * __delh; __h += __delh; const _Tp __dels = __q * __delh; __s += __dels; if ( std::abs(__dels / __s) < __eps ) break; } if (__i > __max_iter) std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.") ); __h = __a1 * __h; __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x)) * std::exp(-__x) / __s; __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi; } _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1; _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu); __Inu = __Inumu * __Inul1 / __Inul; __Ipnu = __Inumu * __Ipnu1 / __Inul; for ( __i = 1; __i <= __nl; ++__i ) { const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu; __Kmu = __Knu1; __Knu1 = __Knutemp; } __Knu = __Kmu; __Kpnu = __nu * __xi * __Kmu - __Knu1; return; } # 267 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3 template _Tp __cyl_bessel_i(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.") ); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__x * __x < _Tp(10) * (__nu + _Tp(1))) return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200); else { _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); return __I_nu; } } # 303 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3 template _Tp __cyl_bessel_k(_Tp __nu, _Tp __x) { if (__nu < _Tp(0) || __x < _Tp(0)) std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.") ); else if (__isnan(__nu) || __isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else { _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu; __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); return __K_nu; } } # 337 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3 template void __sph_bessel_ik(unsigned int __n, _Tp __x, _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n) { const _Tp __nu = _Tp(__n) + _Tp(0.5L); _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu); const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2() / std::sqrt(__x); __i_n = __factor * __I_nu; __k_n = __factor * __K_nu; __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x); __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x); return; } # 373 "/usr/include/c++/10/tr1/modified_bessel_func.tcc" 3 template void __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip) { const _Tp __absx = std::abs(__x); const _Tp __rootx = std::sqrt(__absx); const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3); const _Tp _S_NaN = std::numeric_limits<_Tp>::quiet_NaN(); const _Tp _S_inf = std::numeric_limits<_Tp>::infinity(); if (__isnan(__x)) __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN(); else if (__z == _S_inf) { __Aip = __Ai = _Tp(0); __Bip = __Bi = _S_inf; } else if (__z == -_S_inf) __Bip = __Aip = __Bi = __Ai = _Tp(0); else if (__x > _Tp(0)) { _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu; __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); __Ai = __rootx * __K_nu / (__numeric_constants<_Tp>::__sqrt3() * __numeric_constants<_Tp>::__pi()); __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi() + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu); __Aip = -__x * __K_nu / (__numeric_constants<_Tp>::__sqrt3() * __numeric_constants<_Tp>::__pi()); __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi() + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3()); } else if (__x < _Tp(0)) { _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu; __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); __Ai = __rootx * (__J_nu - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); __Bi = -__rootx * (__N_nu + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2); __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu); __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3() + __J_nu) / _Tp(2); __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3() - __N_nu) / _Tp(2); } else { __Ai = _Tp(0.35502805388781723926L); __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3(); __Aip = -_Tp(0.25881940379280679840L); __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3(); } return; } } } # 57 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/poly_hermite.tcc" 1 3 # 42 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 56 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3 namespace __detail { # 72 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3 template _Tp __poly_hermite_recursion(unsigned int __n, _Tp __x) { _Tp __H_0 = 1; if (__n == 0) return __H_0; _Tp __H_1 = 2 * __x; if (__n == 1) return __H_1; _Tp __H_n, __H_nm1, __H_nm2; unsigned int __i; for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i) { __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2); __H_nm2 = __H_nm1; __H_nm1 = __H_n; } return __H_n; } # 114 "/usr/include/c++/10/tr1/poly_hermite.tcc" 3 template inline _Tp __poly_hermite(unsigned int __n, _Tp __x) { if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else return __poly_hermite_recursion(__n, __x); } } } # 58 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 1 3 # 44 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 60 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 namespace __detail { # 75 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 template _Tp __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x) { const _Tp __a = -_Tp(__n); const _Tp __b = _Tp(__alpha1) + _Tp(1); const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a; const _Tp __cos2th = __x / __eta; const _Tp __sin2th = _Tp(1) - __cos2th; const _Tp __th = std::acos(std::sqrt(__cos2th)); const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2() * __numeric_constants<_Tp>::__pi_2() * __eta * __eta * __cos2th * __sin2th; const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b); const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1)); _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b) * std::log(_Tp(0.25L) * __x * __eta); _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h); _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x + __pre_term1 - __pre_term2; _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi()); _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta * (_Tp(2) * __th - std::sin(_Tp(2) * __th)) + __numeric_constants<_Tp>::__pi_4()); _Tp __ser = __ser_term1 + __ser_term2; return std::exp(__lnpre) * __ser; } # 129 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 template _Tp __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x) { const _Tp __b = _Tp(__alpha1) + _Tp(1); const _Tp __mx = -__x; const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1) : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1))); _Tp __tc = _Tp(1); const _Tp __ax = std::abs(__x); for (unsigned int __k = 1; __k <= __n; ++__k) __tc *= (__ax / __k); _Tp __term = __tc * __tc_sgn; _Tp __sum = __term; for (int __k = int(__n) - 1; __k >= 0; --__k) { __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k)) * _Tp(__k + 1) / __mx; __sum += __term; } return __sum; } # 185 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 template _Tp __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x) { _Tp __l_0 = _Tp(1); if (__n == 0) return __l_0; _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1); if (__n == 1) return __l_1; _Tp __l_n2 = __l_0; _Tp __l_n1 = __l_1; _Tp __l_n = _Tp(0); for (unsigned int __nn = 2; __nn <= __n; ++__nn) { __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x) * __l_n1 / _Tp(__nn) - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn); __l_n2 = __l_n1; __l_n1 = __l_n; } return __l_n; } # 244 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 template _Tp __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x) { if (__x < _Tp(0)) std::__throw_domain_error(("Negative argument " "in __poly_laguerre.") ); else if (__isnan(__x)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__n == 0) return _Tp(1); else if (__n == 1) return _Tp(1) + _Tp(__alpha1) - __x; else if (__x == _Tp(0)) { _Tp __prod = _Tp(__alpha1) + _Tp(1); for (unsigned int __k = 2; __k <= __n; ++__k) __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k); return __prod; } else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1) && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n)) return __poly_laguerre_large_n(__n, __alpha1, __x); else if (_Tp(__alpha1) >= _Tp(0) || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1))) return __poly_laguerre_recursion(__n, __alpha1, __x); else return __poly_laguerre_hyperg(__n, __alpha1, __x); } # 296 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 template inline _Tp __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) { return __poly_laguerre(__n, __m, __x); } # 316 "/usr/include/c++/10/tr1/poly_laguerre.tcc" 3 template inline _Tp __laguerre(unsigned int __n, _Tp __x) { return __poly_laguerre(__n, 0, __x); } } } # 59 "/usr/include/c++/10/bits/specfun.h" 2 3 # 1 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 1 3 # 47 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 63 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 namespace __detail { # 78 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 template _Tp __riemann_zeta_sum(_Tp __s) { if (__s < _Tp(1)) std::__throw_domain_error(("Bad argument in zeta sum.")); const unsigned int max_iter = 10000; _Tp __zeta = _Tp(0); for (unsigned int __k = 1; __k < max_iter; ++__k) { _Tp __term = std::pow(static_cast<_Tp>(__k), -__s); if (__term < std::numeric_limits<_Tp>::epsilon()) { break; } __zeta += __term; } return __zeta; } # 115 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 template _Tp __riemann_zeta_alt(_Tp __s) { _Tp __sgn = _Tp(1); _Tp __zeta = _Tp(0); for (unsigned int __i = 1; __i < 10000000; ++__i) { _Tp __term = __sgn / std::pow(__i, __s); if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon()) break; __zeta += __term; __sgn *= _Tp(-1); } __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); return __zeta; } # 157 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 template _Tp __riemann_zeta_glob(_Tp __s) { _Tp __zeta = _Tp(0); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); if (__s < _Tp(0)) { if (::std::fmod(__s,_Tp(2)) == _Tp(0)) return _Tp(0); else { _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s); __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) * std::exp(::std::lgamma(_Tp(1) - __s)) / __numeric_constants<_Tp>::__pi(); return __zeta; } } _Tp __num = _Tp(0.5L); const unsigned int __maxit = 10000; for (unsigned int __i = 0; __i < __maxit; ++__i) { bool __punt = false; _Tp __sgn = _Tp(1); _Tp __term = _Tp(0); for (unsigned int __j = 0; __j <= __i; ++__j) { _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) - ::std::lgamma(_Tp(1 + __j)) - ::std::lgamma(_Tp(1 + __i - __j)); if (__bincoeff > __max_bincoeff) { __punt = true; break; } __bincoeff = std::exp(__bincoeff); __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s); __sgn *= _Tp(-1); } if (__punt) break; __term *= __num; __zeta += __term; if (std::abs(__term/__zeta) < __eps) break; __num *= _Tp(0.5L); } __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s); return __zeta; } # 252 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 template _Tp __riemann_zeta_product(_Tp __s) { static const _Tp __prime[] = { _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19), _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47), _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79), _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109) }; static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp); _Tp __zeta = _Tp(1); for (unsigned int __i = 0; __i < __num_primes; ++__i) { const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s); __zeta *= __fact; if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon()) break; } __zeta = _Tp(1) / __zeta; return __zeta; } # 293 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 template _Tp __riemann_zeta(_Tp __s) { if (__isnan(__s)) return std::numeric_limits<_Tp>::quiet_NaN(); else if (__s == _Tp(1)) return std::numeric_limits<_Tp>::infinity(); else if (__s < -_Tp(19)) { _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s); __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) * std::exp(::std::lgamma(_Tp(1) - __s)) / __numeric_constants<_Tp>::__pi(); return __zeta; } else if (__s < _Tp(20)) { bool __glob = true; if (__glob) return __riemann_zeta_glob(__s); else { if (__s > _Tp(1)) return __riemann_zeta_sum(__s); else { _Tp __zeta = std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s) * std::sin(__numeric_constants<_Tp>::__pi_2() * __s) * ::std::tgamma(_Tp(1) - __s) * __riemann_zeta_sum(_Tp(1) - __s); return __zeta; } } } else return __riemann_zeta_product(__s); } # 365 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 template _Tp __hurwitz_zeta_glob(_Tp __a, _Tp __s) { _Tp __zeta = _Tp(0); const _Tp __eps = std::numeric_limits<_Tp>::epsilon(); const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10 * std::log(_Tp(10)) - _Tp(1); const unsigned int __maxit = 10000; for (unsigned int __i = 0; __i < __maxit; ++__i) { bool __punt = false; _Tp __sgn = _Tp(1); _Tp __term = _Tp(0); for (unsigned int __j = 0; __j <= __i; ++__j) { _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i)) - ::std::lgamma(_Tp(1 + __j)) - ::std::lgamma(_Tp(1 + __i - __j)); if (__bincoeff > __max_bincoeff) { __punt = true; break; } __bincoeff = std::exp(__bincoeff); __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s); __sgn *= _Tp(-1); } if (__punt) break; __term /= _Tp(__i + 1); if (std::abs(__term / __zeta) < __eps) break; __zeta += __term; } __zeta /= __s - _Tp(1); return __zeta; } # 430 "/usr/include/c++/10/tr1/riemann_zeta.tcc" 3 template inline _Tp __hurwitz_zeta(_Tp __a, _Tp __s) { return __hurwitz_zeta_glob(__a, __s); } } } # 60 "/usr/include/c++/10/bits/specfun.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 205 "/usr/include/c++/10/bits/specfun.h" 3 inline float assoc_laguerref(unsigned int __n, unsigned int __m, float __x) { return __detail::__assoc_laguerre(__n, __m, __x); } inline long double assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x) { return __detail::__assoc_laguerre(__n, __m, __x); } # 250 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__assoc_laguerre<__type>(__n, __m, __x); } # 266 "/usr/include/c++/10/bits/specfun.h" 3 inline float assoc_legendref(unsigned int __l, unsigned int __m, float __x) { return __detail::__assoc_legendre_p(__l, __m, __x); } inline long double assoc_legendrel(unsigned int __l, unsigned int __m, long double __x) { return __detail::__assoc_legendre_p(__l, __m, __x); } # 296 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__assoc_legendre_p<__type>(__l, __m, __x); } # 311 "/usr/include/c++/10/bits/specfun.h" 3 inline float betaf(float __a, float __b) { return __detail::__beta(__a, __b); } inline long double betal(long double __a, long double __b) { return __detail::__beta(__a, __b); } # 341 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type beta(_Tpa __a, _Tpb __b) { typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type; return __detail::__beta<__type>(__a, __b); } # 357 "/usr/include/c++/10/bits/specfun.h" 3 inline float comp_ellint_1f(float __k) { return __detail::__comp_ellint_1(__k); } inline long double comp_ellint_1l(long double __k) { return __detail::__comp_ellint_1(__k); } # 389 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type comp_ellint_1(_Tp __k) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__comp_ellint_1<__type>(__k); } # 405 "/usr/include/c++/10/bits/specfun.h" 3 inline float comp_ellint_2f(float __k) { return __detail::__comp_ellint_2(__k); } inline long double comp_ellint_2l(long double __k) { return __detail::__comp_ellint_2(__k); } # 436 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type comp_ellint_2(_Tp __k) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__comp_ellint_2<__type>(__k); } # 452 "/usr/include/c++/10/bits/specfun.h" 3 inline float comp_ellint_3f(float __k, float __nu) { return __detail::__comp_ellint_3(__k, __nu); } inline long double comp_ellint_3l(long double __k, long double __nu) { return __detail::__comp_ellint_3(__k, __nu); } # 487 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type comp_ellint_3(_Tp __k, _Tpn __nu) { typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type; return __detail::__comp_ellint_3<__type>(__k, __nu); } # 503 "/usr/include/c++/10/bits/specfun.h" 3 inline float cyl_bessel_if(float __nu, float __x) { return __detail::__cyl_bessel_i(__nu, __x); } inline long double cyl_bessel_il(long double __nu, long double __x) { return __detail::__cyl_bessel_i(__nu, __x); } # 533 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_bessel_i(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_bessel_i<__type>(__nu, __x); } # 549 "/usr/include/c++/10/bits/specfun.h" 3 inline float cyl_bessel_jf(float __nu, float __x) { return __detail::__cyl_bessel_j(__nu, __x); } inline long double cyl_bessel_jl(long double __nu, long double __x) { return __detail::__cyl_bessel_j(__nu, __x); } # 579 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_bessel_j(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_bessel_j<__type>(__nu, __x); } # 595 "/usr/include/c++/10/bits/specfun.h" 3 inline float cyl_bessel_kf(float __nu, float __x) { return __detail::__cyl_bessel_k(__nu, __x); } inline long double cyl_bessel_kl(long double __nu, long double __x) { return __detail::__cyl_bessel_k(__nu, __x); } # 631 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_bessel_k(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_bessel_k<__type>(__nu, __x); } # 647 "/usr/include/c++/10/bits/specfun.h" 3 inline float cyl_neumannf(float __nu, float __x) { return __detail::__cyl_neumann_n(__nu, __x); } inline long double cyl_neumannl(long double __nu, long double __x) { return __detail::__cyl_neumann_n(__nu, __x); } # 679 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type cyl_neumann(_Tpnu __nu, _Tp __x) { typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type; return __detail::__cyl_neumann_n<__type>(__nu, __x); } # 695 "/usr/include/c++/10/bits/specfun.h" 3 inline float ellint_1f(float __k, float __phi) { return __detail::__ellint_1(__k, __phi); } inline long double ellint_1l(long double __k, long double __phi) { return __detail::__ellint_1(__k, __phi); } # 727 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type ellint_1(_Tp __k, _Tpp __phi) { typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; return __detail::__ellint_1<__type>(__k, __phi); } # 743 "/usr/include/c++/10/bits/specfun.h" 3 inline float ellint_2f(float __k, float __phi) { return __detail::__ellint_2(__k, __phi); } inline long double ellint_2l(long double __k, long double __phi) { return __detail::__ellint_2(__k, __phi); } # 775 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type ellint_2(_Tp __k, _Tpp __phi) { typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type; return __detail::__ellint_2<__type>(__k, __phi); } # 791 "/usr/include/c++/10/bits/specfun.h" 3 inline float ellint_3f(float __k, float __nu, float __phi) { return __detail::__ellint_3(__k, __nu, __phi); } inline long double ellint_3l(long double __k, long double __nu, long double __phi) { return __detail::__ellint_3(__k, __nu, __phi); } # 828 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi) { typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type; return __detail::__ellint_3<__type>(__k, __nu, __phi); } # 843 "/usr/include/c++/10/bits/specfun.h" 3 inline float expintf(float __x) { return __detail::__expint(__x); } inline long double expintl(long double __x) { return __detail::__expint(__x); } # 868 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type expint(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__expint<__type>(__x); } # 884 "/usr/include/c++/10/bits/specfun.h" 3 inline float hermitef(unsigned int __n, float __x) { return __detail::__poly_hermite(__n, __x); } inline long double hermitel(unsigned int __n, long double __x) { return __detail::__poly_hermite(__n, __x); } # 916 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type hermite(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__poly_hermite<__type>(__n, __x); } # 932 "/usr/include/c++/10/bits/specfun.h" 3 inline float laguerref(unsigned int __n, float __x) { return __detail::__laguerre(__n, __x); } inline long double laguerrel(unsigned int __n, long double __x) { return __detail::__laguerre(__n, __x); } # 960 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type laguerre(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__laguerre<__type>(__n, __x); } # 976 "/usr/include/c++/10/bits/specfun.h" 3 inline float legendref(unsigned int __l, float __x) { return __detail::__poly_legendre_p(__l, __x); } inline long double legendrel(unsigned int __l, long double __x) { return __detail::__poly_legendre_p(__l, __x); } # 1005 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type legendre(unsigned int __l, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__poly_legendre_p<__type>(__l, __x); } # 1021 "/usr/include/c++/10/bits/specfun.h" 3 inline float riemann_zetaf(float __s) { return __detail::__riemann_zeta(__s); } inline long double riemann_zetal(long double __s) { return __detail::__riemann_zeta(__s); } # 1056 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type riemann_zeta(_Tp __s) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__riemann_zeta<__type>(__s); } # 1072 "/usr/include/c++/10/bits/specfun.h" 3 inline float sph_besself(unsigned int __n, float __x) { return __detail::__sph_bessel(__n, __x); } inline long double sph_bessell(unsigned int __n, long double __x) { return __detail::__sph_bessel(__n, __x); } # 1100 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type sph_bessel(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__sph_bessel<__type>(__n, __x); } # 1116 "/usr/include/c++/10/bits/specfun.h" 3 inline float sph_legendref(unsigned int __l, unsigned int __m, float __theta) { return __detail::__sph_legendre(__l, __m, __theta); } # 1127 "/usr/include/c++/10/bits/specfun.h" 3 inline long double sph_legendrel(unsigned int __l, unsigned int __m, long double __theta) { return __detail::__sph_legendre(__l, __m, __theta); } # 1147 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__sph_legendre<__type>(__l, __m, __theta); } # 1163 "/usr/include/c++/10/bits/specfun.h" 3 inline float sph_neumannf(unsigned int __n, float __x) { return __detail::__sph_neumann(__n, __x); } inline long double sph_neumannl(unsigned int __n, long double __x) { return __detail::__sph_neumann(__n, __x); } # 1191 "/usr/include/c++/10/bits/specfun.h" 3 template inline typename __gnu_cxx::__promote<_Tp>::__type sph_neumann(unsigned int __n, _Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __detail::__sph_neumann<__type>(__n, __x); } } # 1388 "/usr/include/c++/10/bits/specfun.h" 3 #pragma GCC visibility pop # 1928 "/usr/include/c++/10/cmath" 2 3 } # 74 "all-std.cxx" 2 # 1 "/usr/include/c++/10/complex" 1 3 # 39 "/usr/include/c++/10/complex" 3 # 40 "/usr/include/c++/10/complex" 3 # 1 "/usr/include/c++/10/cmath" 1 3 # 39 "/usr/include/c++/10/cmath" 3 # 40 "/usr/include/c++/10/cmath" 3 # 45 "/usr/include/c++/10/complex" 2 3 # 1 "/usr/include/c++/10/sstream" 1 3 # 36 "/usr/include/c++/10/sstream" 3 # 37 "/usr/include/c++/10/sstream" 3 # 1 "/usr/include/c++/10/istream" 1 3 # 36 "/usr/include/c++/10/istream" 3 # 37 "/usr/include/c++/10/istream" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 57 "/usr/include/c++/10/istream" 3 template class basic_istream : virtual public basic_ios<_CharT, _Traits> { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef basic_ios<_CharT, _Traits> __ios_type; typedef basic_istream<_CharT, _Traits> __istream_type; typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > __num_get_type; typedef ctype<_CharT> __ctype_type; protected: streamsize _M_gcount; public: explicit basic_istream(__streambuf_type* __sb) : _M_gcount(streamsize(0)) { this->init(__sb); } virtual ~basic_istream() { _M_gcount = streamsize(0); } class sentry; friend class sentry; # 119 "/usr/include/c++/10/istream" 3 __istream_type& operator>>(__istream_type& (*__pf)(__istream_type&)) { return __pf(*this); } __istream_type& operator>>(__ios_type& (*__pf)(__ios_type&)) { __pf(*this); return *this; } __istream_type& operator>>(ios_base& (*__pf)(ios_base&)) { __pf(*this); return *this; } # 167 "/usr/include/c++/10/istream" 3 __istream_type& operator>>(bool& __n) { return _M_extract(__n); } __istream_type& operator>>(short& __n); __istream_type& operator>>(unsigned short& __n) { return _M_extract(__n); } __istream_type& operator>>(int& __n); __istream_type& operator>>(unsigned int& __n) { return _M_extract(__n); } __istream_type& operator>>(long& __n) { return _M_extract(__n); } __istream_type& operator>>(unsigned long& __n) { return _M_extract(__n); } __istream_type& operator>>(long long& __n) { return _M_extract(__n); } __istream_type& operator>>(unsigned long long& __n) { return _M_extract(__n); } # 213 "/usr/include/c++/10/istream" 3 __istream_type& operator>>(float& __f) { return _M_extract(__f); } __istream_type& operator>>(double& __f) { return _M_extract(__f); } __istream_type& operator>>(long double& __f) { return _M_extract(__f); } # 234 "/usr/include/c++/10/istream" 3 __istream_type& operator>>(void*& __p) { return _M_extract(__p); } # 258 "/usr/include/c++/10/istream" 3 __istream_type& operator>>(__streambuf_type* __sb); # 268 "/usr/include/c++/10/istream" 3 streamsize gcount() const { return _M_gcount; } # 301 "/usr/include/c++/10/istream" 3 int_type get(); # 315 "/usr/include/c++/10/istream" 3 __istream_type& get(char_type& __c); # 342 "/usr/include/c++/10/istream" 3 __istream_type& get(char_type* __s, streamsize __n, char_type __delim); # 353 "/usr/include/c++/10/istream" 3 __istream_type& get(char_type* __s, streamsize __n) { return this->get(__s, __n, this->widen('\n')); } # 376 "/usr/include/c++/10/istream" 3 __istream_type& get(__streambuf_type& __sb, char_type __delim); # 386 "/usr/include/c++/10/istream" 3 __istream_type& get(__streambuf_type& __sb) { return this->get(__sb, this->widen('\n')); } # 415 "/usr/include/c++/10/istream" 3 __istream_type& getline(char_type* __s, streamsize __n, char_type __delim); # 426 "/usr/include/c++/10/istream" 3 __istream_type& getline(char_type* __s, streamsize __n) { return this->getline(__s, __n, this->widen('\n')); } # 450 "/usr/include/c++/10/istream" 3 __istream_type& ignore(streamsize __n, int_type __delim); __istream_type& ignore(streamsize __n); __istream_type& ignore(); # 467 "/usr/include/c++/10/istream" 3 int_type peek(); # 485 "/usr/include/c++/10/istream" 3 __istream_type& read(char_type* __s, streamsize __n); # 504 "/usr/include/c++/10/istream" 3 streamsize readsome(char_type* __s, streamsize __n); # 521 "/usr/include/c++/10/istream" 3 __istream_type& putback(char_type __c); # 537 "/usr/include/c++/10/istream" 3 __istream_type& unget(); # 555 "/usr/include/c++/10/istream" 3 int sync(); # 570 "/usr/include/c++/10/istream" 3 pos_type tellg(); # 585 "/usr/include/c++/10/istream" 3 __istream_type& seekg(pos_type); # 601 "/usr/include/c++/10/istream" 3 __istream_type& seekg(off_type, ios_base::seekdir); protected: basic_istream() : _M_gcount(streamsize(0)) { this->init(0); } basic_istream(const basic_istream&) = delete; basic_istream(basic_istream&& __rhs) : __ios_type(), _M_gcount(__rhs._M_gcount) { __ios_type::move(__rhs); __rhs._M_gcount = 0; } basic_istream& operator=(const basic_istream&) = delete; basic_istream& operator=(basic_istream&& __rhs) { swap(__rhs); return *this; } void swap(basic_istream& __rhs) { __ios_type::swap(__rhs); std::swap(_M_gcount, __rhs._M_gcount); } template __istream_type& _M_extract(_ValueT& __v); }; template<> basic_istream& basic_istream:: getline(char_type* __s, streamsize __n, char_type __delim); template<> basic_istream& basic_istream:: ignore(streamsize __n); template<> basic_istream& basic_istream:: ignore(streamsize __n, int_type __delim); template<> basic_istream& basic_istream:: getline(char_type* __s, streamsize __n, char_type __delim); template<> basic_istream& basic_istream:: ignore(streamsize __n); template<> basic_istream& basic_istream:: ignore(streamsize __n, int_type __delim); # 685 "/usr/include/c++/10/istream" 3 template class basic_istream<_CharT, _Traits>::sentry { bool _M_ok; public: typedef _Traits traits_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::__ctype_type __ctype_type; typedef typename _Traits::int_type __int_type; # 721 "/usr/include/c++/10/istream" 3 explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); # 732 "/usr/include/c++/10/istream" 3 explicit operator bool() const { return _M_ok; } }; # 750 "/usr/include/c++/10/istream" 3 template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); template inline basic_istream& operator>>(basic_istream& __in, unsigned char& __c) { return (__in >> reinterpret_cast(__c)); } template inline basic_istream& operator>>(basic_istream& __in, signed char& __c) { return (__in >> reinterpret_cast(__c)); } # 792 "/usr/include/c++/10/istream" 3 template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); template<> basic_istream& operator>>(basic_istream& __in, char* __s); template inline basic_istream& operator>>(basic_istream& __in, unsigned char* __s) { return (__in >> reinterpret_cast(__s)); } template inline basic_istream& operator>>(basic_istream& __in, signed char* __s) { return (__in >> reinterpret_cast(__s)); } # 823 "/usr/include/c++/10/istream" 3 template class basic_iostream : public basic_istream<_CharT, _Traits>, public basic_ostream<_CharT, _Traits> { public: typedef _CharT char_type; typedef typename _Traits::int_type int_type; typedef typename _Traits::pos_type pos_type; typedef typename _Traits::off_type off_type; typedef _Traits traits_type; typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_ostream<_CharT, _Traits> __ostream_type; explicit basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) : __istream_type(__sb), __ostream_type(__sb) { } virtual ~basic_iostream() { } protected: basic_iostream() : __istream_type(), __ostream_type() { } basic_iostream(const basic_iostream&) = delete; basic_iostream(basic_iostream&& __rhs) : __istream_type(std::move(__rhs)), __ostream_type(*this) { } basic_iostream& operator=(const basic_iostream&) = delete; basic_iostream& operator=(basic_iostream&& __rhs) { swap(__rhs); return *this; } void swap(basic_iostream& __rhs) { __istream_type::swap(__rhs); } }; # 906 "/usr/include/c++/10/istream" 3 template basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __is); template basic_istream<_Ch, _Up>& __is_convertible_to_basic_istream_test(basic_istream<_Ch, _Up>*); template struct __is_convertible_to_basic_istream_impl { using __istream_type = void; }; template using __do_is_convertible_to_basic_istream_impl = decltype(__is_convertible_to_basic_istream_test (declval::type*>())); template struct __is_convertible_to_basic_istream_impl <_Tp, __void_t<__do_is_convertible_to_basic_istream_impl<_Tp>>> { using __istream_type = __do_is_convertible_to_basic_istream_impl<_Tp>; }; template struct __is_convertible_to_basic_istream : __is_convertible_to_basic_istream_impl<_Tp> { public: using type = __not_::__istream_type>>; constexpr static bool value = type::value; }; template struct __is_extractable : false_type {}; template struct __is_extractable<_Istream, _Tp, __void_t() >> declval<_Tp>())>> : true_type {}; template using __rvalue_istream_type = typename __is_convertible_to_basic_istream< _Istream>::__istream_type; # 972 "/usr/include/c++/10/istream" 3 template inline typename enable_if<__and_<__not_>, __is_convertible_to_basic_istream<_Istream>, __is_extractable< __rvalue_istream_type<_Istream>, _Tp&&>>::value, __rvalue_istream_type<_Istream>>::type operator>>(_Istream&& __is, _Tp&& __x) { __rvalue_istream_type<_Istream> __ret_is = __is; __ret_is >> std::forward<_Tp>(__x); return __ret_is; } } # 1 "/usr/include/c++/10/bits/istream.tcc" 1 3 # 37 "/usr/include/c++/10/bits/istream.tcc" 3 # 38 "/usr/include/c++/10/bits/istream.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template basic_istream<_CharT, _Traits>::sentry:: sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) { ios_base::iostate __err = ios_base::goodbit; if (__in.good()) try { if (__in.tie()) __in.tie()->flush(); if (!__noskip && bool(__in.flags() & ios_base::skipws)) { const __int_type __eof = traits_type::eof(); __streambuf_type* __sb = __in.rdbuf(); __int_type __c = __sb->sgetc(); const __ctype_type& __ct = __check_facet(__in._M_ctype); while (!traits_type::eq_int_type(__c, __eof) && __ct.is(ctype_base::space, traits_type::to_char_type(__c))) __c = __sb->snextc(); if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(...) { __in._M_setstate(ios_base::badbit); } if (__in.good() && __err == ios_base::goodbit) _M_ok = true; else { __err |= ios_base::failbit; __in.setstate(__err); } } template template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: _M_extract(_ValueT& __v) { sentry __cerb(*this, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __num_get_type& __ng = __check_facet(this->_M_num_get); __ng.get(*this, 0, *this, __err, __v); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(short& __n) { sentry __cerb(*this, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { long __l; const __num_get_type& __ng = __check_facet(this->_M_num_get); __ng.get(*this, 0, *this, __err, __l); if (__l < __gnu_cxx::__numeric_traits::__min) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__min; } else if (__l > __gnu_cxx::__numeric_traits::__max) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__max; } else __n = short(__l); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(int& __n) { sentry __cerb(*this, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { long __l; const __num_get_type& __ng = __check_facet(this->_M_num_get); __ng.get(*this, 0, *this, __err, __l); if (__l < __gnu_cxx::__numeric_traits::__min) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__min; } else if (__l > __gnu_cxx::__numeric_traits::__max) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__max; } else __n = int(__l); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(__streambuf_type* __sbout) { ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, false); if (__cerb && __sbout) { try { bool __ineof; if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) __err |= ios_base::failbit; if (__ineof) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::failbit); throw; } catch(...) { this->_M_setstate(ios_base::failbit); } } else if (!__sbout) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>:: get(void) { const int_type __eof = traits_type::eof(); int_type __c = __eof; _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { __c = this->rdbuf()->sbumpc(); if (!traits_type::eq_int_type(__c, __eof)) _M_gcount = 1; else __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return __c; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(char_type& __c) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __cb = this->rdbuf()->sbumpc(); if (!traits_type::eq_int_type(__cb, traits_type::eof())) { _M_gcount = 1; __c = traits_type::to_char_type(__cb); } else __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(char_type* __s, streamsize __n, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); while (_M_gcount + 1 < __n && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __idelim)) { *__s++ = traits_type::to_char_type(__c); ++_M_gcount; __c = __sb->snextc(); } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (__n > 0) *__s = char_type(); if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(__streambuf_type& __sb, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type* __this_sb = this->rdbuf(); int_type __c = __this_sb->sgetc(); char_type __c2 = traits_type::to_char_type(__c); while (!traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __idelim) && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) { ++_M_gcount; __c = __this_sb->snextc(); __c2 = traits_type::to_char_type(__c); } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: getline(char_type* __s, streamsize __n, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); while (_M_gcount + 1 < __n && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __idelim)) { *__s++ = traits_type::to_char_type(__c); __c = __sb->snextc(); ++_M_gcount; } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; else { if (traits_type::eq_int_type(__c, __idelim)) { __sb->sbumpc(); ++_M_gcount; } else __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } if (__n > 0) *__s = char_type(); if (!_M_gcount) __err |= ios_base::failbit; if (__err) this->setstate(__err); return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(void) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) __err |= ios_base::eofbit; else _M_gcount = 1; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb && __n > 0) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); # 521 "/usr/include/c++/10/bits/istream.tcc" 3 bool __large_ignore = false; while (true) { while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof)) { ++_M_gcount; __c = __sb->snextc(); } if (__n == __gnu_cxx::__numeric_traits::__max && !traits_type::eq_int_type(__c, __eof)) { _M_gcount = __gnu_cxx::__numeric_traits::__min; __large_ignore = true; } else break; } if (__large_ignore) _M_gcount = __gnu_cxx::__numeric_traits::__max; if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(streamsize __n, int_type __delim) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb && __n > 0) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); int_type __c = __sb->sgetc(); bool __large_ignore = false; while (true) { while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __delim)) { ++_M_gcount; __c = __sb->snextc(); } if (__n == __gnu_cxx::__numeric_traits::__max && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __delim)) { _M_gcount = __gnu_cxx::__numeric_traits::__min; __large_ignore = true; } else break; } if (__large_ignore) _M_gcount = __gnu_cxx::__numeric_traits::__max; if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; else if (traits_type::eq_int_type(__c, __delim)) { if (_M_gcount < __gnu_cxx::__numeric_traits::__max) ++_M_gcount; __sb->sbumpc(); } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>:: peek(void) { int_type __c = traits_type::eof(); _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { __c = this->rdbuf()->sgetc(); if (traits_type::eq_int_type(__c, traits_type::eof())) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return __c; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: read(char_type* __s, streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { _M_gcount = this->rdbuf()->sgetn(__s, __n); if (_M_gcount != __n) __err |= (ios_base::eofbit | ios_base::failbit); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template streamsize basic_istream<_CharT, _Traits>:: readsome(char_type* __s, streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const streamsize __num = this->rdbuf()->in_avail(); if (__num > 0) _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); else if (__num == -1) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return _M_gcount; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: putback(char_type __c) { _M_gcount = 0; this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); if (!__sb || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: unget(void) { _M_gcount = 0; this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this->rdbuf(); if (!__sb || traits_type::eq_int_type(__sb->sungetc(), __eof)) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template int basic_istream<_CharT, _Traits>:: sync(void) { int __ret = -1; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { __streambuf_type* __sb = this->rdbuf(); if (__sb) { if (__sb->pubsync() == -1) __err |= ios_base::badbit; else __ret = 0; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return __ret; } template typename basic_istream<_CharT, _Traits>::pos_type basic_istream<_CharT, _Traits>:: tellg(void) { pos_type __ret = pos_type(-1); sentry __cerb(*this, true); if (__cerb) { try { if (!this->fail()) __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } } return __ret; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: seekg(pos_type __pos) { this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::in); if (__p == pos_type(off_type(-1))) __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: seekg(off_type __off, ios_base::seekdir __dir) { this->clear(this->rdstate() & ~ios_base::eofbit); sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { if (!this->fail()) { const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, ios_base::in); if (__p == pos_type(off_type(-1))) __err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this->_M_setstate(ios_base::badbit); throw; } catch(...) { this->_M_setstate(ios_base::badbit); } if (__err) this->setstate(__err); } return *this; } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::int_type __int_type; typename __istream_type::sentry __cerb(__in, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __int_type __cb = __in.rdbuf()->sbumpc(); if (!_Traits::eq_int_type(__cb, _Traits::eof())) __c = _Traits::to_char_type(__cb); else __err |= (ios_base::eofbit | ios_base::failbit); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(...) { __in._M_setstate(ios_base::badbit); } if (__err) __in.setstate(__err); } return __in; } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef typename _Traits::int_type int_type; typedef _CharT char_type; typedef ctype<_CharT> __ctype_type; streamsize __extracted = 0; ios_base::iostate __err = ios_base::goodbit; typename __istream_type::sentry __cerb(__in, false); if (__cerb) { try { streamsize __num = __in.width(); if (__num <= 0) __num = __gnu_cxx::__numeric_traits::__max; const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); const int_type __eof = _Traits::eof(); __streambuf_type* __sb = __in.rdbuf(); int_type __c = __sb->sgetc(); while (__extracted < __num - 1 && !_Traits::eq_int_type(__c, __eof) && !__ct.is(ctype_base::space, _Traits::to_char_type(__c))) { *__s++ = _Traits::to_char_type(__c); ++__extracted; __c = __sb->snextc(); } if (_Traits::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; *__s = char_type(); __in.width(0); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(...) { __in._M_setstate(ios_base::badbit); } } if (!__extracted) __err |= ios_base::failbit; if (__err) __in.setstate(__err); return __in; } template basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __in) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef typename __istream_type::int_type __int_type; typedef ctype<_CharT> __ctype_type; const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); const __int_type __eof = _Traits::eof(); __streambuf_type* __sb = __in.rdbuf(); __int_type __c = __sb->sgetc(); while (!_Traits::eq_int_type(__c, __eof) && __ct.is(ctype_base::space, _Traits::to_char_type(__c))) __c = __sb->snextc(); if (_Traits::eq_int_type(__c, __eof)) __in.setstate(ios_base::eofbit); return __in; } extern template class basic_istream; extern template istream& ws(istream&); extern template istream& operator>>(istream&, char&); extern template istream& operator>>(istream&, char*); extern template istream& operator>>(istream&, unsigned char&); extern template istream& operator>>(istream&, signed char&); extern template istream& operator>>(istream&, unsigned char*); extern template istream& operator>>(istream&, signed char*); extern template istream& istream::_M_extract(unsigned short&); extern template istream& istream::_M_extract(unsigned int&); extern template istream& istream::_M_extract(long&); extern template istream& istream::_M_extract(unsigned long&); extern template istream& istream::_M_extract(bool&); extern template istream& istream::_M_extract(long long&); extern template istream& istream::_M_extract(unsigned long long&); extern template istream& istream::_M_extract(float&); extern template istream& istream::_M_extract(double&); extern template istream& istream::_M_extract(long double&); extern template istream& istream::_M_extract(void*&); extern template class basic_iostream; extern template class basic_istream; extern template wistream& ws(wistream&); extern template wistream& operator>>(wistream&, wchar_t&); extern template wistream& operator>>(wistream&, wchar_t*); extern template wistream& wistream::_M_extract(unsigned short&); extern template wistream& wistream::_M_extract(unsigned int&); extern template wistream& wistream::_M_extract(long&); extern template wistream& wistream::_M_extract(unsigned long&); extern template wistream& wistream::_M_extract(bool&); extern template wistream& wistream::_M_extract(long long&); extern template wistream& wistream::_M_extract(unsigned long long&); extern template wistream& wistream::_M_extract(float&); extern template wistream& wistream::_M_extract(double&); extern template wistream& wistream::_M_extract(long double&); extern template wistream& wistream::_M_extract(void*&); extern template class basic_iostream; } # 992 "/usr/include/c++/10/istream" 2 3 # 39 "/usr/include/c++/10/sstream" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { # 64 "/usr/include/c++/10/sstream" 3 template class basic_stringbuf : public basic_streambuf<_CharT, _Traits> { struct __xfer_bufptrs; public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_streambuf __streambuf_type; typedef basic_string __string_type; typedef typename __string_type::size_type __size_type; protected: ios_base::openmode _M_mode; __string_type _M_string; public: # 99 "/usr/include/c++/10/sstream" 3 basic_stringbuf() : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string() { } # 110 "/usr/include/c++/10/sstream" 3 explicit basic_stringbuf(ios_base::openmode __mode) : __streambuf_type(), _M_mode(__mode), _M_string() { } # 123 "/usr/include/c++/10/sstream" 3 explicit basic_stringbuf(const __string_type& __str, ios_base::openmode __mode = ios_base::in | ios_base::out) : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size(), __str.get_allocator()) { _M_stringbuf_init(__mode); } basic_stringbuf(const basic_stringbuf&) = delete; basic_stringbuf(basic_stringbuf&& __rhs) : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this)) { __rhs._M_sync(const_cast(__rhs._M_string.data()), 0, 0); } basic_stringbuf& operator=(const basic_stringbuf&) = delete; basic_stringbuf& operator=(basic_stringbuf&& __rhs) { __xfer_bufptrs __st{__rhs, this}; const __streambuf_type& __base = __rhs; __streambuf_type::operator=(__base); this->pubimbue(__rhs.getloc()); _M_mode = __rhs._M_mode; _M_string = std::move(__rhs._M_string); __rhs._M_sync(const_cast(__rhs._M_string.data()), 0, 0); return *this; } void swap(basic_stringbuf& __rhs) { __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)}; __xfer_bufptrs __r_st{__rhs, this}; __streambuf_type& __base = __rhs; __streambuf_type::swap(__base); __rhs.pubimbue(this->pubimbue(__rhs.getloc())); std::swap(_M_mode, __rhs._M_mode); std::swap(_M_string, __rhs._M_string); } # 177 "/usr/include/c++/10/sstream" 3 __string_type str() const { __string_type __ret(_M_string.get_allocator()); if (this->pptr()) { if (this->pptr() > this->egptr()) __ret.assign(this->pbase(), this->pptr()); else __ret.assign(this->pbase(), this->egptr()); } else __ret = _M_string; return __ret; } # 201 "/usr/include/c++/10/sstream" 3 void str(const __string_type& __s) { _M_string.assign(__s.data(), __s.size()); _M_stringbuf_init(_M_mode); } protected: void _M_stringbuf_init(ios_base::openmode __mode) { _M_mode = __mode; __size_type __len = 0; if (_M_mode & (ios_base::ate | ios_base::app)) __len = _M_string.size(); _M_sync(const_cast(_M_string.data()), 0, __len); } virtual streamsize showmanyc() { streamsize __ret = -1; if (_M_mode & ios_base::in) { _M_update_egptr(); __ret = this->egptr() - this->gptr(); } return __ret; } virtual int_type underflow(); virtual int_type pbackfail(int_type __c = traits_type::eof()); virtual int_type overflow(int_type __c = traits_type::eof()); # 254 "/usr/include/c++/10/sstream" 3 virtual __streambuf_type* setbuf(char_type* __s, streamsize __n) { if (__s && __n >= 0) { _M_string.clear(); _M_sync(__s, __n, 0); } return this; } virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type __sp, ios_base::openmode __mode = ios_base::in | ios_base::out); void _M_sync(char_type* __base, __size_type __i, __size_type __o); void _M_update_egptr() { const bool __testin = _M_mode & ios_base::in; if (this->pptr() && this->pptr() > this->egptr()) { if (__testin) this->setg(this->eback(), this->gptr(), this->pptr()); else this->setg(this->pptr(), this->pptr(), this->pptr()); } } void _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off); private: struct __xfer_bufptrs { __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to) : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1} { const _CharT* const __str = __from._M_string.data(); const _CharT* __end = nullptr; if (__from.eback()) { _M_goff[0] = __from.eback() - __str; _M_goff[1] = __from.gptr() - __str; _M_goff[2] = __from.egptr() - __str; __end = __from.egptr(); } if (__from.pbase()) { _M_poff[0] = __from.pbase() - __str; _M_poff[1] = __from.pptr() - __from.pbase(); _M_poff[2] = __from.epptr() - __str; if (__from.pptr() > __end) __end = __from.pptr(); } if (__end) { auto& __mut_from = const_cast(__from); __mut_from._M_string._M_length(__end - __str); } } ~__xfer_bufptrs() { char_type* __str = const_cast(_M_to->_M_string.data()); if (_M_goff[0] != -1) _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]); if (_M_poff[0] != -1) _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]); } basic_stringbuf* _M_to; off_type _M_goff[3]; off_type _M_poff[3]; }; # 368 "/usr/include/c++/10/sstream" 3 basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&) : __streambuf_type(static_cast(__rhs)), _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string)) { } }; # 391 "/usr/include/c++/10/sstream" 3 template class basic_istringstream : public basic_istream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_istream __istream_type; private: __stringbuf_type _M_stringbuf; public: # 425 "/usr/include/c++/10/sstream" 3 basic_istringstream() : __istream_type(), _M_stringbuf(ios_base::in) { this->init(&_M_stringbuf); } # 441 "/usr/include/c++/10/sstream" 3 explicit basic_istringstream(ios_base::openmode __mode) : __istream_type(), _M_stringbuf(__mode | ios_base::in) { this->init(&_M_stringbuf); } # 459 "/usr/include/c++/10/sstream" 3 explicit basic_istringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::in) : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in) { this->init(&_M_stringbuf); } ~basic_istringstream() { } basic_istringstream(const basic_istringstream&) = delete; basic_istringstream(basic_istringstream&& __rhs) : __istream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __istream_type::set_rdbuf(&_M_stringbuf); } basic_istringstream& operator=(const basic_istringstream&) = delete; basic_istringstream& operator=(basic_istringstream&& __rhs) { __istream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_istringstream& __rhs) { __istream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } # 510 "/usr/include/c++/10/sstream" 3 __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } __string_type str() const { return _M_stringbuf.str(); } void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; # 549 "/usr/include/c++/10/sstream" 3 template class basic_ostringstream : public basic_ostream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_ostream __ostream_type; private: __stringbuf_type _M_stringbuf; public: # 583 "/usr/include/c++/10/sstream" 3 basic_ostringstream() : __ostream_type(), _M_stringbuf(ios_base::out) { this->init(&_M_stringbuf); } # 599 "/usr/include/c++/10/sstream" 3 explicit basic_ostringstream(ios_base::openmode __mode) : __ostream_type(), _M_stringbuf(__mode | ios_base::out) { this->init(&_M_stringbuf); } # 617 "/usr/include/c++/10/sstream" 3 explicit basic_ostringstream(const __string_type& __str, ios_base::openmode __mode = ios_base::out) : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out) { this->init(&_M_stringbuf); } ~basic_ostringstream() { } basic_ostringstream(const basic_ostringstream&) = delete; basic_ostringstream(basic_ostringstream&& __rhs) : __ostream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __ostream_type::set_rdbuf(&_M_stringbuf); } basic_ostringstream& operator=(const basic_ostringstream&) = delete; basic_ostringstream& operator=(basic_ostringstream&& __rhs) { __ostream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_ostringstream& __rhs) { __ostream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } # 668 "/usr/include/c++/10/sstream" 3 __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } __string_type str() const { return _M_stringbuf.str(); } void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; # 707 "/usr/include/c++/10/sstream" 3 template class basic_stringstream : public basic_iostream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef _Alloc allocator_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type; typedef basic_iostream __iostream_type; private: __stringbuf_type _M_stringbuf; public: # 741 "/usr/include/c++/10/sstream" 3 basic_stringstream() : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in) { this->init(&_M_stringbuf); } # 755 "/usr/include/c++/10/sstream" 3 explicit basic_stringstream(ios_base::openmode __m) : __iostream_type(), _M_stringbuf(__m) { this->init(&_M_stringbuf); } # 771 "/usr/include/c++/10/sstream" 3 explicit basic_stringstream(const __string_type& __str, ios_base::openmode __m = ios_base::out | ios_base::in) : __iostream_type(), _M_stringbuf(__str, __m) { this->init(&_M_stringbuf); } ~basic_stringstream() { } basic_stringstream(const basic_stringstream&) = delete; basic_stringstream(basic_stringstream&& __rhs) : __iostream_type(std::move(__rhs)), _M_stringbuf(std::move(__rhs._M_stringbuf)) { __iostream_type::set_rdbuf(&_M_stringbuf); } basic_stringstream& operator=(const basic_stringstream&) = delete; basic_stringstream& operator=(basic_stringstream&& __rhs) { __iostream_type::operator=(std::move(__rhs)); _M_stringbuf = std::move(__rhs._M_stringbuf); return *this; } void swap(basic_stringstream& __rhs) { __iostream_type::swap(__rhs); _M_stringbuf.swap(__rhs._M_stringbuf); } # 822 "/usr/include/c++/10/sstream" 3 __stringbuf_type* rdbuf() const { return const_cast<__stringbuf_type*>(&_M_stringbuf); } __string_type str() const { return _M_stringbuf.str(); } void str(const __string_type& __s) { _M_stringbuf.str(__s); } }; template inline void swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x, basic_stringbuf<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } template inline void swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x, basic_istringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } template inline void swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x, basic_ostringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } template inline void swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x, basic_stringstream<_CharT, _Traits, _Allocator>& __y) { __x.swap(__y); } } } # 1 "/usr/include/c++/10/bits/sstream.tcc" 1 3 # 37 "/usr/include/c++/10/bits/sstream.tcc" 3 # 38 "/usr/include/c++/10/bits/sstream.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type basic_stringbuf<_CharT, _Traits, _Alloc>:: pbackfail(int_type __c) { int_type __ret = traits_type::eof(); if (this->eback() < this->gptr()) { const bool __testeof = traits_type::eq_int_type(__c, __ret); if (!__testeof) { const bool __testeq = traits_type::eq(traits_type:: to_char_type(__c), this->gptr()[-1]); const bool __testout = this->_M_mode & ios_base::out; if (__testeq || __testout) { this->gbump(-1); if (!__testeq) *this->gptr() = traits_type::to_char_type(__c); __ret = __c; } } else { this->gbump(-1); __ret = traits_type::not_eof(__c); } } return __ret; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type basic_stringbuf<_CharT, _Traits, _Alloc>:: overflow(int_type __c) { const bool __testout = this->_M_mode & ios_base::out; if (__builtin_expect(!__testout, false)) return traits_type::eof(); const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof()); if (__builtin_expect(__testeof, false)) return traits_type::not_eof(__c); const __size_type __capacity = _M_string.capacity(); if (size_t(this->epptr() - this->pbase()) < __capacity) { char_type* __base = const_cast(_M_string.data()); _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase()); if (_M_mode & ios_base::in) { const __size_type __nget = this->gptr() - this->eback(); const __size_type __eget = this->egptr() - this->eback(); this->setg(__base, __base + __nget, __base + __eget + 1); } *this->pptr() = traits_type::to_char_type(__c); this->pbump(1); return __c; } const __size_type __max_size = _M_string.max_size(); const bool __testput = this->pptr() < this->epptr(); if (__builtin_expect(!__testput && __capacity == __max_size, false)) return traits_type::eof(); const char_type __conv = traits_type::to_char_type(__c); if (!__testput) { # 129 "/usr/include/c++/10/bits/sstream.tcc" 3 const __size_type __opt_len = std::max(__size_type(2 * __capacity), __size_type(512)); const __size_type __len = std::min(__opt_len, __max_size); __string_type __tmp(_M_string.get_allocator()); __tmp.reserve(__len); if (this->pbase()) __tmp.assign(this->pbase(), this->epptr() - this->pbase()); __tmp.push_back(__conv); _M_string.swap(__tmp); _M_sync(const_cast(_M_string.data()), this->gptr() - this->eback(), this->pptr() - this->pbase()); } else *this->pptr() = __conv; this->pbump(1); return __c; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type basic_stringbuf<_CharT, _Traits, _Alloc>:: underflow() { int_type __ret = traits_type::eof(); const bool __testin = this->_M_mode & ios_base::in; if (__testin) { _M_update_egptr(); if (this->gptr() < this->egptr()) __ret = traits_type::to_int_type(*this->gptr()); } return __ret; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type basic_stringbuf<_CharT, _Traits, _Alloc>:: seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode) { pos_type __ret = pos_type(off_type(-1)); bool __testin = (ios_base::in & this->_M_mode & __mode) != 0; bool __testout = (ios_base::out & this->_M_mode & __mode) != 0; const bool __testboth = __testin && __testout && __way != ios_base::cur; __testin &= !(__mode & ios_base::out); __testout &= !(__mode & ios_base::in); const char_type* __beg = __testin ? this->eback() : this->pbase(); if ((__beg || !__off) && (__testin || __testout || __testboth)) { _M_update_egptr(); off_type __newoffi = __off; off_type __newoffo = __newoffi; if (__way == ios_base::cur) { __newoffi += this->gptr() - __beg; __newoffo += this->pptr() - __beg; } else if (__way == ios_base::end) __newoffo = __newoffi += this->egptr() - __beg; if ((__testin || __testboth) && __newoffi >= 0 && this->egptr() - __beg >= __newoffi) { this->setg(this->eback(), this->eback() + __newoffi, this->egptr()); __ret = pos_type(__newoffi); } if ((__testout || __testboth) && __newoffo >= 0 && this->egptr() - __beg >= __newoffo) { _M_pbump(this->pbase(), this->epptr(), __newoffo); __ret = pos_type(__newoffo); } } return __ret; } template typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type basic_stringbuf<_CharT, _Traits, _Alloc>:: seekpos(pos_type __sp, ios_base::openmode __mode) { pos_type __ret = pos_type(off_type(-1)); const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0; const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0; const char_type* __beg = __testin ? this->eback() : this->pbase(); if ((__beg || !off_type(__sp)) && (__testin || __testout)) { _M_update_egptr(); const off_type __pos(__sp); const bool __testpos = (0 <= __pos && __pos <= this->egptr() - __beg); if (__testpos) { if (__testin) this->setg(this->eback(), this->eback() + __pos, this->egptr()); if (__testout) _M_pbump(this->pbase(), this->epptr(), __pos); __ret = __sp; } } return __ret; } template void basic_stringbuf<_CharT, _Traits, _Alloc>:: _M_sync(char_type* __base, __size_type __i, __size_type __o) { const bool __testin = _M_mode & ios_base::in; const bool __testout = _M_mode & ios_base::out; char_type* __endg = __base + _M_string.size(); char_type* __endp = __base + _M_string.capacity(); if (__base != _M_string.data()) { __endg += __i; __i = 0; __endp = __endg; } if (__testin) this->setg(__base, __base + __i, __endg); if (__testout) { _M_pbump(__base, __endp, __o); if (!__testin) this->setg(__endg, __endg, __endg); } } template void basic_stringbuf<_CharT, _Traits, _Alloc>:: _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off) { this->setp(__pbeg, __pend); while (__off > __gnu_cxx::__numeric_traits::__max) { this->pbump(__gnu_cxx::__numeric_traits::__max); __off -= __gnu_cxx::__numeric_traits::__max; } this->pbump(__off); } extern template class basic_stringbuf; extern template class basic_istringstream; extern template class basic_ostringstream; extern template class basic_stringstream; extern template class basic_stringbuf; extern template class basic_istringstream; extern template class basic_ostringstream; extern template class basic_stringstream; } # 880 "/usr/include/c++/10/sstream" 2 3 # 46 "/usr/include/c++/10/complex" 2 3 # 54 "/usr/include/c++/10/complex" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 67 "/usr/include/c++/10/complex" 3 template class complex; template<> class complex; template<> class complex; template<> class complex; template _Tp abs(const complex<_Tp>&); template _Tp arg(const complex<_Tp>&); template _Tp constexpr norm(const complex<_Tp>&); template constexpr complex<_Tp> conj(const complex<_Tp>&); template complex<_Tp> polar(const _Tp&, const _Tp& = 0); template complex<_Tp> cos(const complex<_Tp>&); template complex<_Tp> cosh(const complex<_Tp>&); template complex<_Tp> exp(const complex<_Tp>&); template complex<_Tp> log(const complex<_Tp>&); template complex<_Tp> log10(const complex<_Tp>&); template complex<_Tp> pow(const complex<_Tp>&, int); template complex<_Tp> pow(const complex<_Tp>&, const _Tp&); template complex<_Tp> pow(const complex<_Tp>&, const complex<_Tp>&); template complex<_Tp> pow(const _Tp&, const complex<_Tp>&); template complex<_Tp> sin(const complex<_Tp>&); template complex<_Tp> sinh(const complex<_Tp>&); template complex<_Tp> sqrt(const complex<_Tp>&); template complex<_Tp> tan(const complex<_Tp>&); template complex<_Tp> tanh(const complex<_Tp>&); # 126 "/usr/include/c++/10/complex" 3 template struct complex { typedef _Tp value_type; constexpr complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) : _M_real(__r), _M_imag(__i) { } constexpr complex(const complex&) = default; template constexpr complex(const complex<_Up>& __z) : _M_real(__z.real()), _M_imag(__z.imag()) { } __attribute ((__abi_tag__ ("cxx11"))) constexpr _Tp real() const { return _M_real; } __attribute ((__abi_tag__ ("cxx11"))) constexpr _Tp imag() const { return _M_imag; } # 177 "/usr/include/c++/10/complex" 3 constexpr void real(_Tp __val) { _M_real = __val; } constexpr void imag(_Tp __val) { _M_imag = __val; } constexpr complex<_Tp>& operator=(const _Tp&); constexpr complex<_Tp>& operator+=(const _Tp& __t) { _M_real += __t; return *this; } constexpr complex<_Tp>& operator-=(const _Tp& __t) { _M_real -= __t; return *this; } constexpr complex<_Tp>& operator*=(const _Tp&); constexpr complex<_Tp>& operator/=(const _Tp&); constexpr complex& operator=(const complex&) = default; template constexpr complex<_Tp>& operator=(const complex<_Up>&); template constexpr complex<_Tp>& operator+=(const complex<_Up>&); template constexpr complex<_Tp>& operator-=(const complex<_Up>&); template constexpr complex<_Tp>& operator*=(const complex<_Up>&); template constexpr complex<_Tp>& operator/=(const complex<_Up>&); constexpr complex __rep() const { return *this; } private: _Tp _M_real; _Tp _M_imag; }; template constexpr complex<_Tp>& complex<_Tp>::operator=(const _Tp& __t) { _M_real = __t; _M_imag = _Tp(); return *this; } template constexpr complex<_Tp>& complex<_Tp>::operator*=(const _Tp& __t) { _M_real *= __t; _M_imag *= __t; return *this; } template constexpr complex<_Tp>& complex<_Tp>::operator/=(const _Tp& __t) { _M_real /= __t; _M_imag /= __t; return *this; } template template constexpr complex<_Tp>& complex<_Tp>::operator=(const complex<_Up>& __z) { _M_real = __z.real(); _M_imag = __z.imag(); return *this; } template template constexpr complex<_Tp>& complex<_Tp>::operator+=(const complex<_Up>& __z) { _M_real += __z.real(); _M_imag += __z.imag(); return *this; } template template constexpr complex<_Tp>& complex<_Tp>::operator-=(const complex<_Up>& __z) { _M_real -= __z.real(); _M_imag -= __z.imag(); return *this; } template template constexpr complex<_Tp>& complex<_Tp>::operator*=(const complex<_Up>& __z) { const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag(); _M_imag = _M_real * __z.imag() + _M_imag * __z.real(); _M_real = __r; return *this; } template template constexpr complex<_Tp>& complex<_Tp>::operator/=(const complex<_Up>& __z) { const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag(); const _Tp __n = std::norm(__z); _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n; _M_real = __r / __n; return *this; } template inline constexpr complex<_Tp> operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) { complex<_Tp> __r = __x; __r += __y; return __r; } template inline constexpr complex<_Tp> operator+(const complex<_Tp>& __x, const _Tp& __y) { complex<_Tp> __r = __x; __r += __y; return __r; } template inline constexpr complex<_Tp> operator+(const _Tp& __x, const complex<_Tp>& __y) { complex<_Tp> __r = __y; __r += __x; return __r; } template inline constexpr complex<_Tp> operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) { complex<_Tp> __r = __x; __r -= __y; return __r; } template inline constexpr complex<_Tp> operator-(const complex<_Tp>& __x, const _Tp& __y) { complex<_Tp> __r = __x; __r -= __y; return __r; } template inline constexpr complex<_Tp> operator-(const _Tp& __x, const complex<_Tp>& __y) { complex<_Tp> __r = -__y; __r += __x; return __r; } template inline constexpr complex<_Tp> operator*(const complex<_Tp>& __x, const complex<_Tp>& __y) { complex<_Tp> __r = __x; __r *= __y; return __r; } template inline constexpr complex<_Tp> operator*(const complex<_Tp>& __x, const _Tp& __y) { complex<_Tp> __r = __x; __r *= __y; return __r; } template inline constexpr complex<_Tp> operator*(const _Tp& __x, const complex<_Tp>& __y) { complex<_Tp> __r = __y; __r *= __x; return __r; } template inline constexpr complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y) { complex<_Tp> __r = __x; __r /= __y; return __r; } template inline constexpr complex<_Tp> operator/(const complex<_Tp>& __x, const _Tp& __y) { complex<_Tp> __r = __x; __r /= __y; return __r; } template inline constexpr complex<_Tp> operator/(const _Tp& __x, const complex<_Tp>& __y) { complex<_Tp> __r = __x; __r /= __y; return __r; } template inline constexpr complex<_Tp> operator+(const complex<_Tp>& __x) { return __x; } template inline constexpr complex<_Tp> operator-(const complex<_Tp>& __x) { return complex<_Tp>(-__x.real(), -__x.imag()); } template inline constexpr bool operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) { return __x.real() == __y.real() && __x.imag() == __y.imag(); } template inline constexpr bool operator==(const complex<_Tp>& __x, const _Tp& __y) { return __x.real() == __y && __x.imag() == _Tp(); } # 498 "/usr/include/c++/10/complex" 3 template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) { bool __fail = true; _CharT __ch; if (__is >> __ch) { if (_Traits::eq(__ch, __is.widen('('))) { _Tp __u; if (__is >> __u >> __ch) { const _CharT __rparen = __is.widen(')'); if (_Traits::eq(__ch, __rparen)) { __x = __u; __fail = false; } else if (_Traits::eq(__ch, __is.widen(','))) { _Tp __v; if (__is >> __v >> __ch) { if (_Traits::eq(__ch, __rparen)) { __x = complex<_Tp>(__u, __v); __fail = false; } else __is.putback(__ch); } } else __is.putback(__ch); } } else { __is.putback(__ch); _Tp __u; if (__is >> __u) { __x = __u; __fail = false; } } } if (__fail) __is.setstate(ios_base::failbit); return __is; } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) { basic_ostringstream<_CharT, _Traits> __s; __s.flags(__os.flags()); __s.imbue(__os.getloc()); __s.precision(__os.precision()); __s << '(' << __x.real() << ',' << __x.imag() << ')'; return __os << __s.str(); } template constexpr _Tp real(const complex<_Tp>& __z) { return __z.real(); } template constexpr _Tp imag(const complex<_Tp>& __z) { return __z.imag(); } # 598 "/usr/include/c++/10/complex" 3 template inline _Tp __complex_abs(const complex<_Tp>& __z) { _Tp __x = __z.real(); _Tp __y = __z.imag(); const _Tp __s = std::max(abs(__x), abs(__y)); if (__s == _Tp()) return __s; __x /= __s; __y /= __s; return __s * sqrt(__x * __x + __y * __y); } inline float __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); } inline double __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); } inline long double __complex_abs(const __complex__ long double& __z) { return __builtin_cabsl(__z); } template inline _Tp abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); } # 634 "/usr/include/c++/10/complex" 3 template inline _Tp __complex_arg(const complex<_Tp>& __z) { return atan2(__z.imag(), __z.real()); } inline float __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); } inline double __complex_arg(__complex__ double __z) { return __builtin_carg(__z); } inline long double __complex_arg(const __complex__ long double& __z) { return __builtin_cargl(__z); } template inline _Tp arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); } # 664 "/usr/include/c++/10/complex" 3 template struct _Norm_helper { template static inline constexpr _Tp _S_do_it(const complex<_Tp>& __z) { const _Tp __x = __z.real(); const _Tp __y = __z.imag(); return __x * __x + __y * __y; } }; template<> struct _Norm_helper { template static inline constexpr _Tp _S_do_it(const complex<_Tp>& __z) { const _Tp __x = __z.real(); const _Tp __y = __z.imag(); return __x * __x + __y * __y; } }; template inline constexpr _Tp norm(const complex<_Tp>& __z) { return _Norm_helper<__is_floating<_Tp>::__value && !0>::_S_do_it(__z); } template inline complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta) { ; return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); } template inline constexpr complex<_Tp> conj(const complex<_Tp>& __z) { return complex<_Tp>(__z.real(), -__z.imag()); } template inline complex<_Tp> __complex_cos(const complex<_Tp>& __z) { const _Tp __x = __z.real(); const _Tp __y = __z.imag(); return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y)); } inline __complex__ float __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); } inline __complex__ double __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); } inline __complex__ long double __complex_cos(const __complex__ long double& __z) { return __builtin_ccosl(__z); } template inline complex<_Tp> cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); } template inline complex<_Tp> __complex_cosh(const complex<_Tp>& __z) { const _Tp __x = __z.real(); const _Tp __y = __z.imag(); return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y)); } inline __complex__ float __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); } inline __complex__ double __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); } inline __complex__ long double __complex_cosh(const __complex__ long double& __z) { return __builtin_ccoshl(__z); } template inline complex<_Tp> cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); } template inline complex<_Tp> __complex_exp(const complex<_Tp>& __z) { return std::polar<_Tp>(exp(__z.real()), __z.imag()); } inline __complex__ float __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); } inline __complex__ double __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); } inline __complex__ long double __complex_exp(const __complex__ long double& __z) { return __builtin_cexpl(__z); } template inline complex<_Tp> exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); } # 801 "/usr/include/c++/10/complex" 3 template inline complex<_Tp> __complex_log(const complex<_Tp>& __z) { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); } inline __complex__ float __complex_log(__complex__ float __z) { return __builtin_clogf(__z); } inline __complex__ double __complex_log(__complex__ double __z) { return __builtin_clog(__z); } inline __complex__ long double __complex_log(const __complex__ long double& __z) { return __builtin_clogl(__z); } template inline complex<_Tp> log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); } template inline complex<_Tp> log10(const complex<_Tp>& __z) { return std::log(__z) / log(_Tp(10.0)); } template inline complex<_Tp> __complex_sin(const complex<_Tp>& __z) { const _Tp __x = __z.real(); const _Tp __y = __z.imag(); return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); } inline __complex__ float __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); } inline __complex__ double __complex_sin(__complex__ double __z) { return __builtin_csin(__z); } inline __complex__ long double __complex_sin(const __complex__ long double& __z) { return __builtin_csinl(__z); } template inline complex<_Tp> sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); } template inline complex<_Tp> __complex_sinh(const complex<_Tp>& __z) { const _Tp __x = __z.real(); const _Tp __y = __z.imag(); return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y)); } inline __complex__ float __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } inline __complex__ double __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } inline __complex__ long double __complex_sinh(const __complex__ long double& __z) { return __builtin_csinhl(__z); } template inline complex<_Tp> sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); } # 893 "/usr/include/c++/10/complex" 3 template complex<_Tp> __complex_sqrt(const complex<_Tp>& __z) { _Tp __x = __z.real(); _Tp __y = __z.imag(); if (__x == _Tp()) { _Tp __t = sqrt(abs(__y) / 2); return complex<_Tp>(__t, __y < _Tp() ? -__t : __t); } else { _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x))); _Tp __u = __t / 2; return __x > _Tp() ? complex<_Tp>(__u, __y / __t) : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u); } } inline __complex__ float __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); } inline __complex__ double __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); } inline __complex__ long double __complex_sqrt(const __complex__ long double& __z) { return __builtin_csqrtl(__z); } template inline complex<_Tp> sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); } # 937 "/usr/include/c++/10/complex" 3 template inline complex<_Tp> __complex_tan(const complex<_Tp>& __z) { return std::sin(__z) / std::cos(__z); } inline __complex__ float __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); } inline __complex__ double __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); } inline __complex__ long double __complex_tan(const __complex__ long double& __z) { return __builtin_ctanl(__z); } template inline complex<_Tp> tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); } # 965 "/usr/include/c++/10/complex" 3 template inline complex<_Tp> __complex_tanh(const complex<_Tp>& __z) { return std::sinh(__z) / std::cosh(__z); } inline __complex__ float __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); } inline __complex__ double __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); } inline __complex__ long double __complex_tanh(const __complex__ long double& __z) { return __builtin_ctanhl(__z); } template inline complex<_Tp> tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); } # 994 "/usr/include/c++/10/complex" 3 template complex<_Tp> __complex_pow_unsigned(complex<_Tp> __x, unsigned __n) { complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1); while (__n >>= 1) { __x *= __x; if (__n % 2) __y *= __x; } return __y; } template inline complex<_Tp> pow(const complex<_Tp>& __z, int __n) { return __n < 0 ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n) : std::__complex_pow_unsigned(__z, __n); } template complex<_Tp> pow(const complex<_Tp>& __x, const _Tp& __y) { if (__x.imag() == _Tp() && __x.real() > _Tp()) return pow(__x.real(), __y); complex<_Tp> __t = std::log(__x); return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag()); } template inline complex<_Tp> __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y) { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); } inline __complex__ float __complex_pow(__complex__ float __x, __complex__ float __y) { return __builtin_cpowf(__x, __y); } inline __complex__ double __complex_pow(__complex__ double __x, __complex__ double __y) { return __builtin_cpow(__x, __y); } inline __complex__ long double __complex_pow(const __complex__ long double& __x, const __complex__ long double& __y) { return __builtin_cpowl(__x, __y); } template inline complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) { return __complex_pow(__x.__rep(), __y.__rep()); } template inline complex<_Tp> pow(const _Tp& __x, const complex<_Tp>& __y) { return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()), __y.imag() * log(__x)) : std::pow(complex<_Tp>(__x), __y); } template<> struct complex { typedef float value_type; typedef __complex__ float _ComplexT; constexpr complex(_ComplexT __z) : _M_value(__z) { } constexpr complex(float __r = 0.0f, float __i = 0.0f) : _M_value{ __r, __i } { } explicit constexpr complex(const complex&); explicit constexpr complex(const complex&); __attribute ((__abi_tag__ ("cxx11"))) constexpr float real() const { return __real__ _M_value; } __attribute ((__abi_tag__ ("cxx11"))) constexpr float imag() const { return __imag__ _M_value; } # 1128 "/usr/include/c++/10/complex" 3 constexpr void real(float __val) { __real__ _M_value = __val; } constexpr void imag(float __val) { __imag__ _M_value = __val; } constexpr complex& operator=(float __f) { _M_value = __f; return *this; } constexpr complex& operator+=(float __f) { _M_value += __f; return *this; } constexpr complex& operator-=(float __f) { _M_value -= __f; return *this; } constexpr complex& operator*=(float __f) { _M_value *= __f; return *this; } constexpr complex& operator/=(float __f) { _M_value /= __f; return *this; } constexpr complex& operator=(const complex&) = default; template constexpr complex& operator=(const complex<_Tp>& __z) { __real__ _M_value = __z.real(); __imag__ _M_value = __z.imag(); return *this; } template constexpr complex& operator+=(const complex<_Tp>& __z) { _M_value += __z.__rep(); return *this; } template constexpr complex& operator-=(const complex<_Tp>& __z) { _M_value -= __z.__rep(); return *this; } template constexpr complex& operator*=(const complex<_Tp>& __z) { const _ComplexT __t = __z.__rep(); _M_value *= __t; return *this; } template constexpr complex& operator/=(const complex<_Tp>& __z) { const _ComplexT __t = __z.__rep(); _M_value /= __t; return *this; } constexpr _ComplexT __rep() const { return _M_value; } private: _ComplexT _M_value; }; template<> struct complex { typedef double value_type; typedef __complex__ double _ComplexT; constexpr complex(_ComplexT __z) : _M_value(__z) { } constexpr complex(double __r = 0.0, double __i = 0.0) : _M_value{ __r, __i } { } constexpr complex(const complex& __z) : _M_value(__z.__rep()) { } explicit constexpr complex(const complex&); __attribute ((__abi_tag__ ("cxx11"))) constexpr double real() const { return __real__ _M_value; } __attribute ((__abi_tag__ ("cxx11"))) constexpr double imag() const { return __imag__ _M_value; } # 1275 "/usr/include/c++/10/complex" 3 constexpr void real(double __val) { __real__ _M_value = __val; } constexpr void imag(double __val) { __imag__ _M_value = __val; } constexpr complex& operator=(double __d) { _M_value = __d; return *this; } constexpr complex& operator+=(double __d) { _M_value += __d; return *this; } constexpr complex& operator-=(double __d) { _M_value -= __d; return *this; } constexpr complex& operator*=(double __d) { _M_value *= __d; return *this; } constexpr complex& operator/=(double __d) { _M_value /= __d; return *this; } constexpr complex& operator=(const complex&) = default; template constexpr complex& operator=(const complex<_Tp>& __z) { _M_value = __z.__rep(); return *this; } template constexpr complex& operator+=(const complex<_Tp>& __z) { _M_value += __z.__rep(); return *this; } template constexpr complex& operator-=(const complex<_Tp>& __z) { _M_value -= __z.__rep(); return *this; } template constexpr complex& operator*=(const complex<_Tp>& __z) { const _ComplexT __t = __z.__rep(); _M_value *= __t; return *this; } template constexpr complex& operator/=(const complex<_Tp>& __z) { const _ComplexT __t = __z.__rep(); _M_value /= __t; return *this; } constexpr _ComplexT __rep() const { return _M_value; } private: _ComplexT _M_value; }; template<> struct complex { typedef long double value_type; typedef __complex__ long double _ComplexT; constexpr complex(_ComplexT __z) : _M_value(__z) { } constexpr complex(long double __r = 0.0L, long double __i = 0.0L) : _M_value{ __r, __i } { } constexpr complex(const complex& __z) : _M_value(__z.__rep()) { } constexpr complex(const complex& __z) : _M_value(__z.__rep()) { } __attribute ((__abi_tag__ ("cxx11"))) constexpr long double real() const { return __real__ _M_value; } __attribute ((__abi_tag__ ("cxx11"))) constexpr long double imag() const { return __imag__ _M_value; } # 1422 "/usr/include/c++/10/complex" 3 constexpr void real(long double __val) { __real__ _M_value = __val; } constexpr void imag(long double __val) { __imag__ _M_value = __val; } constexpr complex& operator=(long double __r) { _M_value = __r; return *this; } constexpr complex& operator+=(long double __r) { _M_value += __r; return *this; } constexpr complex& operator-=(long double __r) { _M_value -= __r; return *this; } constexpr complex& operator*=(long double __r) { _M_value *= __r; return *this; } constexpr complex& operator/=(long double __r) { _M_value /= __r; return *this; } constexpr complex& operator=(const complex&) = default; template constexpr complex& operator=(const complex<_Tp>& __z) { _M_value = __z.__rep(); return *this; } template constexpr complex& operator+=(const complex<_Tp>& __z) { _M_value += __z.__rep(); return *this; } template constexpr complex& operator-=(const complex<_Tp>& __z) { _M_value -= __z.__rep(); return *this; } template constexpr complex& operator*=(const complex<_Tp>& __z) { const _ComplexT __t = __z.__rep(); _M_value *= __t; return *this; } template constexpr complex& operator/=(const complex<_Tp>& __z) { const _ComplexT __t = __z.__rep(); _M_value /= __t; return *this; } constexpr _ComplexT __rep() const { return _M_value; } private: _ComplexT _M_value; }; inline constexpr complex::complex(const complex& __z) : _M_value(__z.__rep()) { } inline constexpr complex::complex(const complex& __z) : _M_value(__z.__rep()) { } inline constexpr complex::complex(const complex& __z) : _M_value(__z.__rep()) { } extern template istream& operator>>(istream&, complex&); extern template ostream& operator<<(ostream&, const complex&); extern template istream& operator>>(istream&, complex&); extern template ostream& operator<<(ostream&, const complex&); extern template istream& operator>>(istream&, complex&); extern template ostream& operator<<(ostream&, const complex&); extern template wistream& operator>>(wistream&, complex&); extern template wostream& operator<<(wostream&, const complex&); extern template wistream& operator>>(wistream&, complex&); extern template wostream& operator<<(wostream&, const complex&); extern template wistream& operator>>(wistream&, complex&); extern template wostream& operator<<(wostream&, const complex&); } namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { template struct __promote_2, _Up> { public: typedef std::complex::__type> __type; }; template struct __promote_2<_Tp, std::complex<_Up> > { public: typedef std::complex::__type> __type; }; template struct __promote_2, std::complex<_Up> > { public: typedef std::complex::__type> __type; }; } namespace std __attribute__ ((__visibility__ ("default"))) { template std::complex<_Tp> acos(const std::complex<_Tp>&); template std::complex<_Tp> asin(const std::complex<_Tp>&); template std::complex<_Tp> atan(const std::complex<_Tp>&); template std::complex<_Tp> acosh(const std::complex<_Tp>&); template std::complex<_Tp> asinh(const std::complex<_Tp>&); template std::complex<_Tp> atanh(const std::complex<_Tp>&); template _Tp fabs(const std::complex<_Tp>&); template inline std::complex<_Tp> __complex_acos(const std::complex<_Tp>& __z) { const std::complex<_Tp> __t = std::asin(__z); const _Tp __pi_2 = 1.5707963267948966192313216916397514L; return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag()); } inline __complex__ float __complex_acos(__complex__ float __z) { return __builtin_cacosf(__z); } inline __complex__ double __complex_acos(__complex__ double __z) { return __builtin_cacos(__z); } inline __complex__ long double __complex_acos(const __complex__ long double& __z) { return __builtin_cacosl(__z); } template inline std::complex<_Tp> acos(const std::complex<_Tp>& __z) { return __complex_acos(__z.__rep()); } # 1638 "/usr/include/c++/10/complex" 3 template inline std::complex<_Tp> __complex_asin(const std::complex<_Tp>& __z) { std::complex<_Tp> __t(-__z.imag(), __z.real()); __t = std::asinh(__t); return std::complex<_Tp>(__t.imag(), -__t.real()); } inline __complex__ float __complex_asin(__complex__ float __z) { return __builtin_casinf(__z); } inline __complex__ double __complex_asin(__complex__ double __z) { return __builtin_casin(__z); } inline __complex__ long double __complex_asin(const __complex__ long double& __z) { return __builtin_casinl(__z); } template inline std::complex<_Tp> asin(const std::complex<_Tp>& __z) { return __complex_asin(__z.__rep()); } # 1674 "/usr/include/c++/10/complex" 3 template std::complex<_Tp> __complex_atan(const std::complex<_Tp>& __z) { const _Tp __r2 = __z.real() * __z.real(); const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag(); _Tp __num = __z.imag() + _Tp(1.0); _Tp __den = __z.imag() - _Tp(1.0); __num = __r2 + __num * __num; __den = __r2 + __den * __den; return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x), _Tp(0.25) * log(__num / __den)); } inline __complex__ float __complex_atan(__complex__ float __z) { return __builtin_catanf(__z); } inline __complex__ double __complex_atan(__complex__ double __z) { return __builtin_catan(__z); } inline __complex__ long double __complex_atan(const __complex__ long double& __z) { return __builtin_catanl(__z); } template inline std::complex<_Tp> atan(const std::complex<_Tp>& __z) { return __complex_atan(__z.__rep()); } # 1718 "/usr/include/c++/10/complex" 3 template std::complex<_Tp> __complex_acosh(const std::complex<_Tp>& __z) { return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0))) + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0)))); } inline __complex__ float __complex_acosh(__complex__ float __z) { return __builtin_cacoshf(__z); } inline __complex__ double __complex_acosh(__complex__ double __z) { return __builtin_cacosh(__z); } inline __complex__ long double __complex_acosh(const __complex__ long double& __z) { return __builtin_cacoshl(__z); } template inline std::complex<_Tp> acosh(const std::complex<_Tp>& __z) { return __complex_acosh(__z.__rep()); } # 1754 "/usr/include/c++/10/complex" 3 template std::complex<_Tp> __complex_asinh(const std::complex<_Tp>& __z) { std::complex<_Tp> __t((__z.real() - __z.imag()) * (__z.real() + __z.imag()) + _Tp(1.0), _Tp(2.0) * __z.real() * __z.imag()); __t = std::sqrt(__t); return std::log(__t + __z); } inline __complex__ float __complex_asinh(__complex__ float __z) { return __builtin_casinhf(__z); } inline __complex__ double __complex_asinh(__complex__ double __z) { return __builtin_casinh(__z); } inline __complex__ long double __complex_asinh(const __complex__ long double& __z) { return __builtin_casinhl(__z); } template inline std::complex<_Tp> asinh(const std::complex<_Tp>& __z) { return __complex_asinh(__z.__rep()); } # 1793 "/usr/include/c++/10/complex" 3 template std::complex<_Tp> __complex_atanh(const std::complex<_Tp>& __z) { const _Tp __i2 = __z.imag() * __z.imag(); const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real(); _Tp __num = _Tp(1.0) + __z.real(); _Tp __den = _Tp(1.0) - __z.real(); __num = __i2 + __num * __num; __den = __i2 + __den * __den; return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)), _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x)); } inline __complex__ float __complex_atanh(__complex__ float __z) { return __builtin_catanhf(__z); } inline __complex__ double __complex_atanh(__complex__ double __z) { return __builtin_catanh(__z); } inline __complex__ long double __complex_atanh(const __complex__ long double& __z) { return __builtin_catanhl(__z); } template inline std::complex<_Tp> atanh(const std::complex<_Tp>& __z) { return __complex_atanh(__z.__rep()); } # 1837 "/usr/include/c++/10/complex" 3 template inline _Tp fabs(const std::complex<_Tp>& __z) { return std::abs(__z); } template inline typename __gnu_cxx::__promote<_Tp>::__type arg(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L) : __type(); } template constexpr inline typename __gnu_cxx::__promote<_Tp>::__type imag(_Tp) { return _Tp(); } template constexpr inline typename __gnu_cxx::__promote<_Tp>::__type norm(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return __type(__x) * __type(__x); } template constexpr inline typename __gnu_cxx::__promote<_Tp>::__type real(_Tp __x) { return __x; } template inline std::complex::__type> pow(const std::complex<_Tp>& __x, const _Up& __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::pow(std::complex<__type>(__x), __type(__y)); } template inline std::complex::__type> pow(const _Tp& __x, const std::complex<_Up>& __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::pow(__type(__x), std::complex<__type>(__y)); } template inline std::complex::__type> pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y) { typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; return std::pow(std::complex<__type>(__x), std::complex<__type>(__y)); } template std::complex<_Tp> proj(const std::complex<_Tp>&); template inline std::complex<_Tp> __complex_proj(const std::complex<_Tp>& __z) { return __z; } inline complex __complex_proj(const complex& __z) { return __builtin_cprojf(__z.__rep()); } inline complex __complex_proj(const complex& __z) { return __builtin_cproj(__z.__rep()); } inline complex __complex_proj(const complex& __z) { return __builtin_cprojl(__z.__rep()); } # 1954 "/usr/include/c++/10/complex" 3 template inline std::complex<_Tp> proj(const std::complex<_Tp>& __z) { return __complex_proj(__z); } template inline std::complex::__type> proj(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return std::proj(std::complex<__type>(__x)); } template inline constexpr std::complex::__type> conj(_Tp __x) { typedef typename __gnu_cxx::__promote<_Tp>::__type __type; return std::complex<__type>(__x, -__type()); } inline namespace literals { inline namespace complex_literals { #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wliteral-suffix" constexpr std::complex operator""if(long double __num) { return std::complex{0.0F, static_cast(__num)}; } constexpr std::complex operator""if(unsigned long long __num) { return std::complex{0.0F, static_cast(__num)}; } constexpr std::complex operator""i(long double __num) { return std::complex{0.0, static_cast(__num)}; } constexpr std::complex operator""i(unsigned long long __num) { return std::complex{0.0, static_cast(__num)}; } constexpr std::complex operator""il(long double __num) { return std::complex{0.0L, __num}; } constexpr std::complex operator""il(unsigned long long __num) { return std::complex{0.0L, static_cast(__num)}; } #pragma GCC diagnostic pop } } } # 75 "all-std.cxx" 2 # 1 "/usr/include/c++/10/numbers" 1 3 # 32 "/usr/include/c++/10/numbers" 3 # 33 "/usr/include/c++/10/numbers" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace numbers { template using _Enable_if_floating = enable_if_t, _Tp>; template inline constexpr _Tp e_v = _Enable_if_floating<_Tp>(2.718281828459045235360287471352662498L); template inline constexpr _Tp log2e_v = _Enable_if_floating<_Tp>(1.442695040888963407359924681001892137L); template inline constexpr _Tp log10e_v = _Enable_if_floating<_Tp>(0.434294481903251827651128918916605082L); template inline constexpr _Tp pi_v = _Enable_if_floating<_Tp>(3.141592653589793238462643383279502884L); template inline constexpr _Tp inv_pi_v = _Enable_if_floating<_Tp>(0.318309886183790671537767526745028724L); template inline constexpr _Tp inv_sqrtpi_v = _Enable_if_floating<_Tp>(0.564189583547756286948079451560772586L); template inline constexpr _Tp ln2_v = _Enable_if_floating<_Tp>(0.693147180559945309417232121458176568L); template inline constexpr _Tp ln10_v = _Enable_if_floating<_Tp>(2.302585092994045684017991454684364208L); template inline constexpr _Tp sqrt2_v = _Enable_if_floating<_Tp>(1.414213562373095048801688724209698079L); template inline constexpr _Tp sqrt3_v = _Enable_if_floating<_Tp>(1.732050807568877293527446341505872367L); template inline constexpr _Tp inv_sqrt3_v = _Enable_if_floating<_Tp>(0.577350269189625764509148780501957456L); template inline constexpr _Tp egamma_v = _Enable_if_floating<_Tp>(0.577215664901532860606512090082402431L); template inline constexpr _Tp phi_v = _Enable_if_floating<_Tp>(1.618033988749894848204586834365638118L); inline constexpr double e = e_v; inline constexpr double log2e = log2e_v; inline constexpr double log10e = log10e_v; inline constexpr double pi = pi_v; inline constexpr double inv_pi = inv_pi_v; inline constexpr double inv_sqrtpi = inv_sqrtpi_v; inline constexpr double ln2 = ln2_v; inline constexpr double ln10 = ln10_v; inline constexpr double sqrt2 = sqrt2_v; inline constexpr double sqrt3 = sqrt3_v; inline constexpr double inv_sqrt3 = inv_sqrt3_v; inline constexpr double egamma = egamma_v; inline constexpr double phi = phi_v; # 202 "/usr/include/c++/10/numbers" 3 } } # 76 "all-std.cxx" 2 # 1 "/usr/include/c++/10/random" 1 3 # 32 "/usr/include/c++/10/random" 3 # 33 "/usr/include/c++/10/random" 3 # 1 "/usr/include/c++/10/cmath" 1 3 # 39 "/usr/include/c++/10/cmath" 3 # 40 "/usr/include/c++/10/cmath" 3 # 39 "/usr/include/c++/10/random" 2 3 # 1 "/usr/include/c++/10/cstdlib" 1 3 # 39 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/random" 2 3 # 49 "/usr/include/c++/10/random" 3 # 1 "/usr/include/c++/10/bits/random.h" 1 3 # 37 "/usr/include/c++/10/bits/random.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 58 "/usr/include/c++/10/bits/random.h" 3 template _RealType generate_canonical(_UniformRandomNumberGenerator& __g); namespace __detail { template (std::numeric_limits<_UIntType>::digits)> struct _Shift { static const _UIntType __value = 0; }; template struct _Shift<_UIntType, __w, true> { static const _UIntType __value = _UIntType(1) << __w; }; template struct _Select_uint_least_t { static_assert(__which < 0, "sorry, would be too much trouble for a slow result"); }; template struct _Select_uint_least_t<__s, 4> { typedef unsigned int type; }; template struct _Select_uint_least_t<__s, 3> { typedef unsigned long type; }; template struct _Select_uint_least_t<__s, 2> { typedef unsigned long long type; }; template struct _Select_uint_least_t<__s, 1> { typedef unsigned __int128 type; }; template= __m - 1), bool __schrage_ok = __m % __a < __m / __a> struct _Mod { typedef typename _Select_uint_least_t::type _Tp2; static _Tp __calc(_Tp __x) { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); } }; template struct _Mod<_Tp, __m, __a, __c, false, true> { static _Tp __calc(_Tp __x); }; template struct _Mod<_Tp, __m, __a, __c, true, __s> { static _Tp __calc(_Tp __x) { _Tp __res = __a * __x + __c; if (__m) __res %= __m; return __res; } }; template inline _Tp __mod(_Tp __x) { if constexpr (__a == 0) return __c; else { constexpr _Tp __a1 = __a ? __a : 1; return _Mod<_Tp, __m, __a1, __c>::__calc(__x); } } template struct _Adaptor { static_assert(std::is_floating_point<_DInputType>::value, "template argument must be a floating point type"); public: _Adaptor(_Engine& __g) : _M_g(__g) { } _DInputType min() const { return _DInputType(0); } _DInputType max() const { return _DInputType(1); } _DInputType operator()() { return std::generate_canonical<_DInputType, std::numeric_limits<_DInputType>::digits, _Engine>(_M_g); } private: _Engine& _M_g; }; template using __seed_seq_generate_t = decltype( std::declval<_Sseq&>().generate(std::declval(), std::declval())); template> using __is_seed_seq = __and_< __not_, _Engine>>, is_unsigned, __not_> >; } # 254 "/usr/include/c++/10/bits/random.h" 3 template class linear_congruential_engine { static_assert(std::is_unsigned<_UIntType>::value, "result_type must be an unsigned integral type"); static_assert(__m == 0u || (__a < __m && __c < __m), "template argument substituting __m out of bounds"); template using _If_seed_seq = typename enable_if<__detail::__is_seed_seq< _Sseq, linear_congruential_engine, _UIntType>::value>::type; public: typedef _UIntType result_type; static constexpr result_type multiplier = __a; static constexpr result_type increment = __c; static constexpr result_type modulus = __m; static constexpr result_type default_seed = 1u; linear_congruential_engine() : linear_congruential_engine(default_seed) { } # 292 "/usr/include/c++/10/bits/random.h" 3 explicit linear_congruential_engine(result_type __s) { seed(__s); } template> explicit linear_congruential_engine(_Sseq& __q) { seed(__q); } void seed(result_type __s = default_seed); # 323 "/usr/include/c++/10/bits/random.h" 3 template _If_seed_seq<_Sseq> seed(_Sseq& __q); static constexpr result_type min() { return __c == 0u ? 1u : 0u; } static constexpr result_type max() { return __m - 1u; } void discard(unsigned long long __z) { for (; __z != 0ULL; --__z) (*this)(); } result_type operator()() { _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x); return _M_x; } # 375 "/usr/include/c++/10/bits/random.h" 3 friend bool operator==(const linear_congruential_engine& __lhs, const linear_congruential_engine& __rhs) { return __lhs._M_x == __rhs._M_x; } # 388 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::linear_congruential_engine<_UIntType1, __a1, __c1, __m1>& __lcr); # 408 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::linear_congruential_engine<_UIntType1, __a1, __c1, __m1>& __lcr); private: _UIntType _M_x; }; # 430 "/usr/include/c++/10/bits/random.h" 3 template inline bool operator!=(const std::linear_congruential_engine<_UIntType, __a, __c, __m>& __lhs, const std::linear_congruential_engine<_UIntType, __a, __c, __m>& __rhs) { return !(__lhs == __rhs); } # 467 "/usr/include/c++/10/bits/random.h" 3 template class mersenne_twister_engine { static_assert(std::is_unsigned<_UIntType>::value, "result_type must be an unsigned integral type"); static_assert(1u <= __m && __m <= __n, "template argument substituting __m out of bounds"); static_assert(__r <= __w, "template argument substituting " "__r out of bound"); static_assert(__u <= __w, "template argument substituting " "__u out of bound"); static_assert(__s <= __w, "template argument substituting " "__s out of bound"); static_assert(__t <= __w, "template argument substituting " "__t out of bound"); static_assert(__l <= __w, "template argument substituting " "__l out of bound"); static_assert(__w <= std::numeric_limits<_UIntType>::digits, "template argument substituting __w out of bound"); static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1), "template argument substituting __a out of bound"); static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1), "template argument substituting __b out of bound"); static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1), "template argument substituting __c out of bound"); static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1), "template argument substituting __d out of bound"); static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1), "template argument substituting __f out of bound"); template using _If_seed_seq = typename enable_if<__detail::__is_seed_seq< _Sseq, mersenne_twister_engine, _UIntType>::value>::type; public: typedef _UIntType result_type; static constexpr size_t word_size = __w; static constexpr size_t state_size = __n; static constexpr size_t shift_size = __m; static constexpr size_t mask_bits = __r; static constexpr result_type xor_mask = __a; static constexpr size_t tempering_u = __u; static constexpr result_type tempering_d = __d; static constexpr size_t tempering_s = __s; static constexpr result_type tempering_b = __b; static constexpr size_t tempering_t = __t; static constexpr result_type tempering_c = __c; static constexpr size_t tempering_l = __l; static constexpr result_type initialization_multiplier = __f; static constexpr result_type default_seed = 5489u; mersenne_twister_engine() : mersenne_twister_engine(default_seed) { } explicit mersenne_twister_engine(result_type __sd) { seed(__sd); } template> explicit mersenne_twister_engine(_Sseq& __q) { seed(__q); } void seed(result_type __sd = default_seed); template _If_seed_seq<_Sseq> seed(_Sseq& __q); static constexpr result_type min() { return 0; } static constexpr result_type max() { return __detail::_Shift<_UIntType, __w>::__value - 1; } void discard(unsigned long long __z); result_type operator()(); # 586 "/usr/include/c++/10/bits/random.h" 3 friend bool operator==(const mersenne_twister_engine& __lhs, const mersenne_twister_engine& __rhs) { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x) && __lhs._M_p == __rhs._M_p); } # 604 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1>& __x); # 630 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1>& __x); private: void _M_gen_rand(); _UIntType _M_x[state_size]; size_t _M_p; }; # 663 "/usr/include/c++/10/bits/random.h" 3 template inline bool operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs, const std::mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs) { return !(__lhs == __rhs); } # 691 "/usr/include/c++/10/bits/random.h" 3 template class subtract_with_carry_engine { static_assert(std::is_unsigned<_UIntType>::value, "result_type must be an unsigned integral type"); static_assert(0u < __s && __s < __r, "0 < s < r"); static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, "template argument substituting __w out of bounds"); template using _If_seed_seq = typename enable_if<__detail::__is_seed_seq< _Sseq, subtract_with_carry_engine, _UIntType>::value>::type; public: typedef _UIntType result_type; static constexpr size_t word_size = __w; static constexpr size_t short_lag = __s; static constexpr size_t long_lag = __r; static constexpr result_type default_seed = 19780503u; subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) { } explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); } template> explicit subtract_with_carry_engine(_Sseq& __q) { seed(__q); } # 749 "/usr/include/c++/10/bits/random.h" 3 void seed(result_type __sd = default_seed); template _If_seed_seq<_Sseq> seed(_Sseq& __q); static constexpr result_type min() { return 0; } static constexpr result_type max() { return __detail::_Shift<_UIntType, __w>::__value - 1; } void discard(unsigned long long __z) { for (; __z != 0ULL; --__z) (*this)(); } result_type operator()(); # 804 "/usr/include/c++/10/bits/random.h" 3 friend bool operator==(const subtract_with_carry_engine& __lhs, const subtract_with_carry_engine& __rhs) { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x) && __lhs._M_carry == __rhs._M_carry && __lhs._M_p == __rhs._M_p); } # 823 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::subtract_with_carry_engine<_UIntType1, __w1, __s1, __r1>& __x); # 842 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::subtract_with_carry_engine<_UIntType1, __w1, __s1, __r1>& __x); private: _UIntType _M_x[long_lag]; _UIntType _M_carry; size_t _M_p; }; # 868 "/usr/include/c++/10/bits/random.h" 3 template inline bool operator!=(const std::subtract_with_carry_engine<_UIntType, __w, __s, __r>& __lhs, const std::subtract_with_carry_engine<_UIntType, __w, __s, __r>& __rhs) { return !(__lhs == __rhs); } # 883 "/usr/include/c++/10/bits/random.h" 3 template class discard_block_engine { static_assert(1 <= __r && __r <= __p, "template argument substituting __r out of bounds"); public: typedef typename _RandomNumberEngine::result_type result_type; template using _If_seed_seq = typename enable_if<__detail::__is_seed_seq< _Sseq, discard_block_engine, result_type>::value>::type; static constexpr size_t block_size = __p; static constexpr size_t used_block = __r; discard_block_engine() : _M_b(), _M_n(0) { } explicit discard_block_engine(const _RandomNumberEngine& __rng) : _M_b(__rng), _M_n(0) { } explicit discard_block_engine(_RandomNumberEngine&& __rng) : _M_b(std::move(__rng)), _M_n(0) { } explicit discard_block_engine(result_type __s) : _M_b(__s), _M_n(0) { } template> explicit discard_block_engine(_Sseq& __q) : _M_b(__q), _M_n(0) { } void seed() { _M_b.seed(); _M_n = 0; } void seed(result_type __s) { _M_b.seed(__s); _M_n = 0; } template _If_seed_seq<_Sseq> seed(_Sseq& __q) { _M_b.seed(__q); _M_n = 0; } const _RandomNumberEngine& base() const noexcept { return _M_b; } static constexpr result_type min() { return _RandomNumberEngine::min(); } static constexpr result_type max() { return _RandomNumberEngine::max(); } void discard(unsigned long long __z) { for (; __z != 0ULL; --__z) (*this)(); } result_type operator()(); # 1034 "/usr/include/c++/10/bits/random.h" 3 friend bool operator==(const discard_block_engine& __lhs, const discard_block_engine& __rhs) { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; } # 1050 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::discard_block_engine<_RandomNumberEngine1, __p1, __r1>& __x); # 1068 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::discard_block_engine<_RandomNumberEngine1, __p1, __r1>& __x); private: _RandomNumberEngine _M_b; size_t _M_n; }; # 1091 "/usr/include/c++/10/bits/random.h" 3 template inline bool operator!=(const std::discard_block_engine<_RandomNumberEngine, __p, __r>& __lhs, const std::discard_block_engine<_RandomNumberEngine, __p, __r>& __rhs) { return !(__lhs == __rhs); } template class independent_bits_engine { static_assert(std::is_unsigned<_UIntType>::value, "result_type must be an unsigned integral type"); static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, "template argument substituting __w out of bounds"); template using _If_seed_seq = typename enable_if<__detail::__is_seed_seq< _Sseq, independent_bits_engine, _UIntType>::value>::type; public: typedef _UIntType result_type; independent_bits_engine() : _M_b() { } explicit independent_bits_engine(const _RandomNumberEngine& __rng) : _M_b(__rng) { } explicit independent_bits_engine(_RandomNumberEngine&& __rng) : _M_b(std::move(__rng)) { } explicit independent_bits_engine(result_type __s) : _M_b(__s) { } template> explicit independent_bits_engine(_Sseq& __q) : _M_b(__q) { } void seed() { _M_b.seed(); } void seed(result_type __s) { _M_b.seed(__s); } template _If_seed_seq<_Sseq> seed(_Sseq& __q) { _M_b.seed(__q); } const _RandomNumberEngine& base() const noexcept { return _M_b; } static constexpr result_type min() { return 0U; } static constexpr result_type max() { return __detail::_Shift<_UIntType, __w>::__value - 1; } void discard(unsigned long long __z) { for (; __z != 0ULL; --__z) (*this)(); } result_type operator()(); # 1245 "/usr/include/c++/10/bits/random.h" 3 friend bool operator==(const independent_bits_engine& __lhs, const independent_bits_engine& __rhs) { return __lhs._M_b == __rhs._M_b; } # 1262 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::independent_bits_engine<_RandomNumberEngine, __w, _UIntType>& __x) { __is >> __x._M_b; return __is; } private: _RandomNumberEngine _M_b; }; # 1288 "/usr/include/c++/10/bits/random.h" 3 template inline bool operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w, _UIntType>& __lhs, const std::independent_bits_engine<_RandomNumberEngine, __w, _UIntType>& __rhs) { return !(__lhs == __rhs); } # 1306 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::independent_bits_engine<_RandomNumberEngine, __w, _UIntType>& __x) { __os << __x.base(); return __os; } template class shuffle_order_engine { static_assert(1u <= __k, "template argument substituting " "__k out of bound"); public: typedef typename _RandomNumberEngine::result_type result_type; template using _If_seed_seq = typename enable_if<__detail::__is_seed_seq< _Sseq, shuffle_order_engine, result_type>::value>::type; static constexpr size_t table_size = __k; shuffle_order_engine() : _M_b() { _M_initialize(); } explicit shuffle_order_engine(const _RandomNumberEngine& __rng) : _M_b(__rng) { _M_initialize(); } explicit shuffle_order_engine(_RandomNumberEngine&& __rng) : _M_b(std::move(__rng)) { _M_initialize(); } explicit shuffle_order_engine(result_type __s) : _M_b(__s) { _M_initialize(); } template> explicit shuffle_order_engine(_Sseq& __q) : _M_b(__q) { _M_initialize(); } void seed() { _M_b.seed(); _M_initialize(); } void seed(result_type __s) { _M_b.seed(__s); _M_initialize(); } template _If_seed_seq<_Sseq> seed(_Sseq& __q) { _M_b.seed(__q); _M_initialize(); } const _RandomNumberEngine& base() const noexcept { return _M_b; } static constexpr result_type min() { return _RandomNumberEngine::min(); } static constexpr result_type max() { return _RandomNumberEngine::max(); } void discard(unsigned long long __z) { for (; __z != 0ULL; --__z) (*this)(); } result_type operator()(); # 1475 "/usr/include/c++/10/bits/random.h" 3 friend bool operator==(const shuffle_order_engine& __lhs, const shuffle_order_engine& __rhs) { return (__lhs._M_b == __rhs._M_b && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v) && __lhs._M_y == __rhs._M_y); } # 1493 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x); # 1511 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x); private: void _M_initialize() { for (size_t __i = 0; __i < __k; ++__i) _M_v[__i] = _M_b(); _M_y = _M_b(); } _RandomNumberEngine _M_b; result_type _M_v[__k]; result_type _M_y; }; # 1541 "/usr/include/c++/10/bits/random.h" 3 template inline bool operator!=(const std::shuffle_order_engine<_RandomNumberEngine, __k>& __lhs, const std::shuffle_order_engine<_RandomNumberEngine, __k>& __rhs) { return !(__lhs == __rhs); } typedef linear_congruential_engine minstd_rand0; typedef linear_congruential_engine minstd_rand; # 1570 "/usr/include/c++/10/bits/random.h" 3 typedef mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL> mt19937; typedef mersenne_twister_engine< uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL> mt19937_64; typedef subtract_with_carry_engine ranlux24_base; typedef subtract_with_carry_engine ranlux48_base; typedef discard_block_engine ranlux24; typedef discard_block_engine ranlux48; typedef shuffle_order_engine knuth_b; typedef minstd_rand0 default_random_engine; class random_device { public: typedef unsigned int result_type; random_device() { _M_init("default"); } explicit random_device(const std::string& __token) { _M_init(__token); } ~random_device() { _M_fini(); } static constexpr result_type min() { return std::numeric_limits::min(); } static constexpr result_type max() { return std::numeric_limits::max(); } double entropy() const noexcept { return this->_M_getentropy(); } result_type operator()() { return this->_M_getval(); } random_device(const random_device&) = delete; void operator=(const random_device&) = delete; private: void _M_init(const std::string& __token); void _M_init_pretr1(const std::string& __token); void _M_fini(); result_type _M_getval(); result_type _M_getval_pretr1(); double _M_getentropy() const noexcept; void _M_init(const char*, size_t); union { struct { void* _M_file; result_type (*_M_func)(void*); int _M_fd; }; mt19937 _M_mt; }; }; # 1696 "/usr/include/c++/10/bits/random.h" 3 template inline bool operator!=(const std::uniform_int_distribution<_IntType>& __d1, const std::uniform_int_distribution<_IntType>& __d2) { return !(__d1 == __d2); } # 1712 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>&, const std::uniform_int_distribution<_IntType>&); # 1726 "/usr/include/c++/10/bits/random.h" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>&, std::uniform_int_distribution<_IntType>&); # 1739 "/usr/include/c++/10/bits/random.h" 3 template class uniform_real_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef uniform_real_distribution<_RealType> distribution_type; param_type() : param_type(0) { } explicit param_type(_RealType __a, _RealType __b = _RealType(1)) : _M_a(__a), _M_b(__b) { ; } result_type a() const { return _M_a; } result_type b() const { return _M_b; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_a; _RealType _M_b; }; public: uniform_real_distribution() : uniform_real_distribution(0.0) { } explicit uniform_real_distribution(_RealType __a, _RealType __b = _RealType(1)) : _M_param(__a, __b) { } explicit uniform_real_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } result_type a() const { return _M_param.a(); } result_type b() const { return _M_param.b(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return this->a(); } result_type max() const { return this->b(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); return (__aurng() * (__p.b() - __p.a())) + __p.a(); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const uniform_real_distribution& __d1, const uniform_real_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::uniform_real_distribution<_IntType>& __d1, const std::uniform_real_distribution<_IntType>& __d2) { return !(__d1 == __d2); } # 1933 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>&, const std::uniform_real_distribution<_RealType>&); # 1947 "/usr/include/c++/10/bits/random.h" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>&, std::uniform_real_distribution<_RealType>&); # 1969 "/usr/include/c++/10/bits/random.h" 3 template class normal_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef normal_distribution<_RealType> distribution_type; param_type() : param_type(0.0) { } explicit param_type(_RealType __mean, _RealType __stddev = _RealType(1)) : _M_mean(__mean), _M_stddev(__stddev) { ; } _RealType mean() const { return _M_mean; } _RealType stddev() const { return _M_stddev; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return (__p1._M_mean == __p2._M_mean && __p1._M_stddev == __p2._M_stddev); } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_mean; _RealType _M_stddev; }; public: normal_distribution() : normal_distribution(0.0) { } explicit normal_distribution(result_type __mean, result_type __stddev = result_type(1)) : _M_param(__mean, __stddev) { } explicit normal_distribution(const param_type& __p) : _M_param(__p) { } void reset() { _M_saved_available = false; } _RealType mean() const { return _M_param.mean(); } _RealType stddev() const { return _M_param.stddev(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return std::numeric_limits::lowest(); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template friend bool operator==(const std::normal_distribution<_RealType1>& __d1, const std::normal_distribution<_RealType1>& __d2); # 2138 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::normal_distribution<_RealType1>& __x); # 2153 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::normal_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; result_type _M_saved = 0; bool _M_saved_available = false; }; template inline bool operator!=(const std::normal_distribution<_RealType>& __d1, const std::normal_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 2190 "/usr/include/c++/10/bits/random.h" 3 template class lognormal_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef lognormal_distribution<_RealType> distribution_type; param_type() : param_type(0.0) { } explicit param_type(_RealType __m, _RealType __s = _RealType(1)) : _M_m(__m), _M_s(__s) { } _RealType m() const { return _M_m; } _RealType s() const { return _M_s; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_m; _RealType _M_s; }; lognormal_distribution() : lognormal_distribution(0.0) { } explicit lognormal_distribution(_RealType __m, _RealType __s = _RealType(1)) : _M_param(__m, __s), _M_nd() { } explicit lognormal_distribution(const param_type& __p) : _M_param(__p), _M_nd() { } void reset() { _M_nd.reset(); } _RealType m() const { return _M_param.m(); } _RealType s() const { return _M_param.s(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return result_type(0); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const lognormal_distribution& __d1, const lognormal_distribution& __d2) { return (__d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd); } # 2349 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::lognormal_distribution<_RealType1>& __x); # 2364 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::lognormal_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; std::normal_distribution _M_nd; }; template inline bool operator!=(const std::lognormal_distribution<_RealType>& __d1, const std::lognormal_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 2401 "/usr/include/c++/10/bits/random.h" 3 template class gamma_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef gamma_distribution<_RealType> distribution_type; friend class gamma_distribution<_RealType>; param_type() : param_type(1.0) { } explicit param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1)) : _M_alpha(__alpha_val), _M_beta(__beta_val) { ; _M_initialize(); } _RealType alpha() const { return _M_alpha; } _RealType beta() const { return _M_beta; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return (__p1._M_alpha == __p2._M_alpha && __p1._M_beta == __p2._M_beta); } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: void _M_initialize(); _RealType _M_alpha; _RealType _M_beta; _RealType _M_malpha, _M_a2; }; public: gamma_distribution() : gamma_distribution(1.0) { } explicit gamma_distribution(_RealType __alpha_val, _RealType __beta_val = _RealType(1)) : _M_param(__alpha_val, __beta_val), _M_nd() { } explicit gamma_distribution(const param_type& __p) : _M_param(__p), _M_nd() { } void reset() { _M_nd.reset(); } _RealType alpha() const { return _M_param.alpha(); } _RealType beta() const { return _M_param.beta(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return result_type(0); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const gamma_distribution& __d1, const gamma_distribution& __d2) { return (__d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd); } # 2581 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::gamma_distribution<_RealType1>& __x); # 2595 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::gamma_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; std::normal_distribution _M_nd; }; template inline bool operator!=(const std::gamma_distribution<_RealType>& __d1, const std::gamma_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 2629 "/usr/include/c++/10/bits/random.h" 3 template class chi_squared_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef chi_squared_distribution<_RealType> distribution_type; param_type() : param_type(1) { } explicit param_type(_RealType __n) : _M_n(__n) { } _RealType n() const { return _M_n; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_n == __p2._M_n; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_n; }; chi_squared_distribution() : chi_squared_distribution(1) { } explicit chi_squared_distribution(_RealType __n) : _M_param(__n), _M_gd(__n / 2) { } explicit chi_squared_distribution(const param_type& __p) : _M_param(__p), _M_gd(__p.n() / 2) { } void reset() { _M_gd.reset(); } _RealType n() const { return _M_param.n(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; typedef typename std::gamma_distribution::param_type param_type; _M_gd.param(param_type{__param.n() / 2}); } result_type min() const { return result_type(0); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return 2 * _M_gd(__urng); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { typedef typename std::gamma_distribution::param_type param_type; return 2 * _M_gd(__urng, param_type(__p.n() / 2)); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { typename std::gamma_distribution::param_type __p2(__p.n() / 2); this->__generate_impl(__f, __t, __urng, __p2); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { typename std::gamma_distribution::param_type __p2(__p.n() / 2); this->__generate_impl(__f, __t, __urng, __p2); } friend bool operator==(const chi_squared_distribution& __d1, const chi_squared_distribution& __d2) { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; } # 2797 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::chi_squared_distribution<_RealType1>& __x); # 2812 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::chi_squared_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng); template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const typename std::gamma_distribution::param_type& __p); param_type _M_param; std::gamma_distribution _M_gd; }; template inline bool operator!=(const std::chi_squared_distribution<_RealType>& __d1, const std::chi_squared_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 2853 "/usr/include/c++/10/bits/random.h" 3 template class cauchy_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef cauchy_distribution<_RealType> distribution_type; param_type() : param_type(0) { } explicit param_type(_RealType __a, _RealType __b = _RealType(1)) : _M_a(__a), _M_b(__b) { } _RealType a() const { return _M_a; } _RealType b() const { return _M_b; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_a; _RealType _M_b; }; cauchy_distribution() : cauchy_distribution(0.0) { } explicit cauchy_distribution(_RealType __a, _RealType __b = 1.0) : _M_param(__a, __b) { } explicit cauchy_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } _RealType a() const { return _M_param.a(); } _RealType 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 std::numeric_limits::lowest(); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const cauchy_distribution& __d1, const cauchy_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::cauchy_distribution<_RealType>& __d1, const std::cauchy_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 3030 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::cauchy_distribution<_RealType>& __x); # 3045 "/usr/include/c++/10/bits/random.h" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::cauchy_distribution<_RealType>& __x); # 3061 "/usr/include/c++/10/bits/random.h" 3 template class fisher_f_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef fisher_f_distribution<_RealType> distribution_type; param_type() : param_type(1) { } explicit param_type(_RealType __m, _RealType __n = _RealType(1)) : _M_m(__m), _M_n(__n) { } _RealType m() const { return _M_m; } _RealType n() const { return _M_n; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_m; _RealType _M_n; }; fisher_f_distribution() : fisher_f_distribution(1.0) { } explicit fisher_f_distribution(_RealType __m, _RealType __n = _RealType(1)) : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2) { } explicit fisher_f_distribution(const param_type& __p) : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2) { } void reset() { _M_gd_x.reset(); _M_gd_y.reset(); } _RealType m() const { return _M_param.m(); } _RealType n() const { return _M_param.n(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return result_type(0); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { typedef typename std::gamma_distribution::param_type param_type; return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n()) / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m())); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const fisher_f_distribution& __d1, const fisher_f_distribution& __d2) { return (__d1._M_param == __d2._M_param && __d1._M_gd_x == __d2._M_gd_x && __d1._M_gd_y == __d2._M_gd_y); } # 3236 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::fisher_f_distribution<_RealType1>& __x); # 3251 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::fisher_f_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng); template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; std::gamma_distribution _M_gd_x, _M_gd_y; }; template inline bool operator!=(const std::fisher_f_distribution<_RealType>& __d1, const std::fisher_f_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 3293 "/usr/include/c++/10/bits/random.h" 3 template class student_t_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef student_t_distribution<_RealType> distribution_type; param_type() : param_type(1) { } explicit param_type(_RealType __n) : _M_n(__n) { } _RealType n() const { return _M_n; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_n == __p2._M_n; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_n; }; student_t_distribution() : student_t_distribution(1.0) { } explicit student_t_distribution(_RealType __n) : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2) { } explicit student_t_distribution(const param_type& __p) : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2) { } void reset() { _M_nd.reset(); _M_gd.reset(); } _RealType n() const { return _M_param.n(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return std::numeric_limits::lowest(); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { typedef typename std::gamma_distribution::param_type param_type; const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2)); return _M_nd(__urng) * std::sqrt(__p.n() / __g); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const student_t_distribution& __d1, const student_t_distribution& __d2) { return (__d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); } # 3458 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::student_t_distribution<_RealType1>& __x); # 3473 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::student_t_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng); template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; std::normal_distribution _M_nd; std::gamma_distribution _M_gd; }; template inline bool operator!=(const std::student_t_distribution<_RealType>& __d1, const std::student_t_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 3521 "/usr/include/c++/10/bits/random.h" 3 class bernoulli_distribution { public: typedef bool result_type; struct param_type { typedef bernoulli_distribution distribution_type; param_type() : param_type(0.5) { } explicit param_type(double __p) : _M_p(__p) { ; } double p() const { return _M_p; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_p == __p2._M_p; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: double _M_p; }; public: bernoulli_distribution() : bernoulli_distribution(0.5) { } explicit bernoulli_distribution(double __p) : _M_param(__p) { } explicit bernoulli_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } double p() const { return _M_param.p(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return std::numeric_limits::min(); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); if ((__aurng() - __aurng.min()) < __p.p() * (__aurng.max() - __aurng.min())) return true; return false; } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const bernoulli_distribution& __d1, const bernoulli_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; inline bool operator!=(const std::bernoulli_distribution& __d1, const std::bernoulli_distribution& __d2) { return !(__d1 == __d2); } # 3704 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::bernoulli_distribution& __x); # 3718 "/usr/include/c++/10/bits/random.h" 3 template inline std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::bernoulli_distribution& __x) { double __p; if (__is >> __p) __x.param(bernoulli_distribution::param_type(__p)); return __is; } # 3737 "/usr/include/c++/10/bits/random.h" 3 template class binomial_distribution { static_assert(std::is_integral<_IntType>::value, "result_type must be an integral type"); public: typedef _IntType result_type; struct param_type { typedef binomial_distribution<_IntType> distribution_type; friend class binomial_distribution<_IntType>; param_type() : param_type(1) { } explicit param_type(_IntType __t, double __p = 0.5) : _M_t(__t), _M_p(__p) { ; _M_initialize(); } _IntType t() const { return _M_t; } double p() const { return _M_p; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: void _M_initialize(); _IntType _M_t; double _M_p; double _M_q; double _M_d1, _M_d2, _M_s1, _M_s2, _M_c, _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p; bool _M_easy; }; binomial_distribution() : binomial_distribution(1) { } explicit binomial_distribution(_IntType __t, double __p = 0.5) : _M_param(__t, __p), _M_nd() { } explicit binomial_distribution(const param_type& __p) : _M_param(__p), _M_nd() { } void reset() { _M_nd.reset(); } _IntType t() const { return _M_param.t(); } double p() const { return _M_param.p(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return 0; } result_type max() const { return _M_param.t(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const binomial_distribution& __d1, const binomial_distribution& __d2) { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; } # 3919 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::binomial_distribution<_IntType1>& __x); # 3935 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::binomial_distribution<_IntType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); template result_type _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t, double __q); param_type _M_param; std::normal_distribution _M_nd; }; template inline bool operator!=(const std::binomial_distribution<_IntType>& __d1, const std::binomial_distribution<_IntType>& __d2) { return !(__d1 == __d2); } # 3977 "/usr/include/c++/10/bits/random.h" 3 template class geometric_distribution { static_assert(std::is_integral<_IntType>::value, "result_type must be an integral type"); public: typedef _IntType result_type; struct param_type { typedef geometric_distribution<_IntType> distribution_type; friend class geometric_distribution<_IntType>; param_type() : param_type(0.5) { } explicit param_type(double __p) : _M_p(__p) { ; _M_initialize(); } double p() const { return _M_p; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_p == __p2._M_p; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: void _M_initialize() { _M_log_1_p = std::log(1.0 - _M_p); } double _M_p; double _M_log_1_p; }; geometric_distribution() : geometric_distribution(0.5) { } explicit geometric_distribution(double __p) : _M_param(__p) { } explicit geometric_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } double p() const { return _M_param.p(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return 0; } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const geometric_distribution& __d1, const geometric_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::geometric_distribution<_IntType>& __d1, const std::geometric_distribution<_IntType>& __d2) { return !(__d1 == __d2); } # 4158 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::geometric_distribution<_IntType>& __x); # 4173 "/usr/include/c++/10/bits/random.h" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::geometric_distribution<_IntType>& __x); # 4187 "/usr/include/c++/10/bits/random.h" 3 template class negative_binomial_distribution { static_assert(std::is_integral<_IntType>::value, "result_type must be an integral type"); public: typedef _IntType result_type; struct param_type { typedef negative_binomial_distribution<_IntType> distribution_type; param_type() : param_type(1) { } explicit param_type(_IntType __k, double __p = 0.5) : _M_k(__k), _M_p(__p) { ; } _IntType k() const { return _M_k; } double p() const { return _M_p; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _IntType _M_k; double _M_p; }; negative_binomial_distribution() : negative_binomial_distribution(1) { } explicit negative_binomial_distribution(_IntType __k, double __p = 0.5) : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p) { } explicit negative_binomial_distribution(const param_type& __p) : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p()) { } void reset() { _M_gd.reset(); } _IntType k() const { return _M_param.k(); } double p() const { return _M_param.p(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return result_type(0); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng); template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng) { this->__generate_impl(__f, __t, __urng); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const negative_binomial_distribution& __d1, const negative_binomial_distribution& __d2) { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; } # 4355 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::negative_binomial_distribution<_IntType1>& __x); # 4370 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::negative_binomial_distribution<_IntType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng); template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; std::gamma_distribution _M_gd; }; template inline bool operator!=(const std::negative_binomial_distribution<_IntType>& __d1, const std::negative_binomial_distribution<_IntType>& __d2) { return !(__d1 == __d2); } # 4418 "/usr/include/c++/10/bits/random.h" 3 template class poisson_distribution { static_assert(std::is_integral<_IntType>::value, "result_type must be an integral type"); public: typedef _IntType result_type; struct param_type { typedef poisson_distribution<_IntType> distribution_type; friend class poisson_distribution<_IntType>; param_type() : param_type(1.0) { } explicit param_type(double __mean) : _M_mean(__mean) { ; _M_initialize(); } double mean() const { return _M_mean; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_mean == __p2._M_mean; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: void _M_initialize(); double _M_mean; double _M_lm_thr; double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb; }; poisson_distribution() : poisson_distribution(1.0) { } explicit poisson_distribution(double __mean) : _M_param(__mean), _M_nd() { } explicit poisson_distribution(const param_type& __p) : _M_param(__p), _M_nd() { } void reset() { _M_nd.reset(); } double mean() const { return _M_param.mean(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return 0; } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const poisson_distribution& __d1, const poisson_distribution& __d2) { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; } # 4585 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::poisson_distribution<_IntType1>& __x); # 4600 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::poisson_distribution<_IntType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; std::normal_distribution _M_nd; }; template inline bool operator!=(const std::poisson_distribution<_IntType>& __d1, const std::poisson_distribution<_IntType>& __d2) { return !(__d1 == __d2); } # 4644 "/usr/include/c++/10/bits/random.h" 3 template class exponential_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef exponential_distribution<_RealType> distribution_type; param_type() : param_type(1.0) { } explicit param_type(_RealType __lambda) : _M_lambda(__lambda) { ; } _RealType lambda() const { return _M_lambda; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_lambda == __p2._M_lambda; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_lambda; }; public: exponential_distribution() : exponential_distribution(1.0) { } explicit exponential_distribution(_RealType __lambda) : _M_param(__lambda) { } explicit exponential_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } _RealType lambda() const { return _M_param.lambda(); } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return result_type(0); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); return -std::log(result_type(1) - __aurng()) / __p.lambda(); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const exponential_distribution& __d1, const exponential_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::exponential_distribution<_RealType>& __d1, const std::exponential_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 4829 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::exponential_distribution<_RealType>& __x); # 4844 "/usr/include/c++/10/bits/random.h" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::exponential_distribution<_RealType>& __x); # 4859 "/usr/include/c++/10/bits/random.h" 3 template class weibull_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef weibull_distribution<_RealType> distribution_type; param_type() : param_type(1.0) { } explicit param_type(_RealType __a, _RealType __b = _RealType(1.0)) : _M_a(__a), _M_b(__b) { } _RealType a() const { return _M_a; } _RealType b() const { return _M_b; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_a; _RealType _M_b; }; weibull_distribution() : weibull_distribution(1.0) { } explicit weibull_distribution(_RealType __a, _RealType __b = _RealType(1)) : _M_param(__a, __b) { } explicit weibull_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } _RealType a() const { return _M_param.a(); } _RealType 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 result_type(0); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const weibull_distribution& __d1, const weibull_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::weibull_distribution<_RealType>& __d1, const std::weibull_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 5039 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::weibull_distribution<_RealType>& __x); # 5054 "/usr/include/c++/10/bits/random.h" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::weibull_distribution<_RealType>& __x); # 5069 "/usr/include/c++/10/bits/random.h" 3 template class extreme_value_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef extreme_value_distribution<_RealType> distribution_type; param_type() : param_type(0.0) { } explicit param_type(_RealType __a, _RealType __b = _RealType(1.0)) : _M_a(__a), _M_b(__b) { } _RealType a() const { return _M_a; } _RealType b() const { return _M_b; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: _RealType _M_a; _RealType _M_b; }; extreme_value_distribution() : extreme_value_distribution(0.0) { } explicit extreme_value_distribution(_RealType __a, _RealType __b = _RealType(1)) : _M_param(__a, __b) { } explicit extreme_value_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } _RealType a() const { return _M_param.a(); } _RealType 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 std::numeric_limits::lowest(); } result_type max() const { return std::numeric_limits::max(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const extreme_value_distribution& __d1, const extreme_value_distribution& __d2) { return __d1._M_param == __d2._M_param; } private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::extreme_value_distribution<_RealType>& __d1, const std::extreme_value_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 5249 "/usr/include/c++/10/bits/random.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::extreme_value_distribution<_RealType>& __x); # 5264 "/usr/include/c++/10/bits/random.h" 3 template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::extreme_value_distribution<_RealType>& __x); # 5276 "/usr/include/c++/10/bits/random.h" 3 template class discrete_distribution { static_assert(std::is_integral<_IntType>::value, "result_type must be an integral type"); public: typedef _IntType result_type; struct param_type { typedef discrete_distribution<_IntType> distribution_type; friend class discrete_distribution<_IntType>; param_type() : _M_prob(), _M_cp() { } template param_type(_InputIterator __wbegin, _InputIterator __wend) : _M_prob(__wbegin, __wend), _M_cp() { _M_initialize(); } param_type(initializer_list __wil) : _M_prob(__wil.begin(), __wil.end()), _M_cp() { _M_initialize(); } template param_type(size_t __nw, double __xmin, double __xmax, _Func __fw); param_type(const param_type&) = default; param_type& operator=(const param_type&) = default; std::vector probabilities() const { return _M_prob.empty() ? std::vector(1, 1.0) : _M_prob; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_prob == __p2._M_prob; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: void _M_initialize(); std::vector _M_prob; std::vector _M_cp; }; discrete_distribution() : _M_param() { } template discrete_distribution(_InputIterator __wbegin, _InputIterator __wend) : _M_param(__wbegin, __wend) { } discrete_distribution(initializer_list __wl) : _M_param(__wl) { } template discrete_distribution(size_t __nw, double __xmin, double __xmax, _Func __fw) : _M_param(__nw, __xmin, __xmax, __fw) { } explicit discrete_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } std::vector probabilities() const { return _M_param._M_prob.empty() ? std::vector(1, 1.0) : _M_param._M_prob; } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return result_type(0); } result_type max() const { return _M_param._M_prob.empty() ? result_type(0) : result_type(_M_param._M_prob.size() - 1); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const discrete_distribution& __d1, const discrete_distribution& __d2) { return __d1._M_param == __d2._M_param; } # 5462 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::discrete_distribution<_IntType1>& __x); # 5478 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::discrete_distribution<_IntType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::discrete_distribution<_IntType>& __d1, const std::discrete_distribution<_IntType>& __d2) { return !(__d1 == __d2); } # 5511 "/usr/include/c++/10/bits/random.h" 3 template class piecewise_constant_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef piecewise_constant_distribution<_RealType> distribution_type; friend class piecewise_constant_distribution<_RealType>; param_type() : _M_int(), _M_den(), _M_cp() { } template param_type(_InputIteratorB __bfirst, _InputIteratorB __bend, _InputIteratorW __wbegin); template param_type(initializer_list<_RealType> __bi, _Func __fw); template param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw); param_type(const param_type&) = default; param_type& operator=(const param_type&) = default; std::vector<_RealType> intervals() const { if (_M_int.empty()) { std::vector<_RealType> __tmp(2); __tmp[1] = _RealType(1); return __tmp; } else return _M_int; } std::vector densities() const { return _M_den.empty() ? std::vector(1, 1.0) : _M_den; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: void _M_initialize(); std::vector<_RealType> _M_int; std::vector _M_den; std::vector _M_cp; }; piecewise_constant_distribution() : _M_param() { } template piecewise_constant_distribution(_InputIteratorB __bfirst, _InputIteratorB __bend, _InputIteratorW __wbegin) : _M_param(__bfirst, __bend, __wbegin) { } template piecewise_constant_distribution(initializer_list<_RealType> __bl, _Func __fw) : _M_param(__bl, __fw) { } template piecewise_constant_distribution(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw) : _M_param(__nw, __xmin, __xmax, __fw) { } explicit piecewise_constant_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } std::vector<_RealType> intervals() const { if (_M_param._M_int.empty()) { std::vector<_RealType> __tmp(2); __tmp[1] = _RealType(1); return __tmp; } else return _M_param._M_int; } std::vector densities() const { return _M_param._M_den.empty() ? std::vector(1, 1.0) : _M_param._M_den; } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return _M_param._M_int.empty() ? result_type(0) : _M_param._M_int.front(); } result_type max() const { return _M_param._M_int.empty() ? result_type(1) : _M_param._M_int.back(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const piecewise_constant_distribution& __d1, const piecewise_constant_distribution& __d2) { return __d1._M_param == __d2._M_param; } # 5733 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::piecewise_constant_distribution<_RealType1>& __x); # 5749 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::piecewise_constant_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::piecewise_constant_distribution<_RealType>& __d1, const std::piecewise_constant_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 5782 "/usr/include/c++/10/bits/random.h" 3 template class piecewise_linear_distribution { static_assert(std::is_floating_point<_RealType>::value, "result_type must be a floating point type"); public: typedef _RealType result_type; struct param_type { typedef piecewise_linear_distribution<_RealType> distribution_type; friend class piecewise_linear_distribution<_RealType>; param_type() : _M_int(), _M_den(), _M_cp(), _M_m() { } template param_type(_InputIteratorB __bfirst, _InputIteratorB __bend, _InputIteratorW __wbegin); template param_type(initializer_list<_RealType> __bl, _Func __fw); template param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw); param_type(const param_type&) = default; param_type& operator=(const param_type&) = default; std::vector<_RealType> intervals() const { if (_M_int.empty()) { std::vector<_RealType> __tmp(2); __tmp[1] = _RealType(1); return __tmp; } else return _M_int; } std::vector densities() const { return _M_den.empty() ? std::vector(2, 1.0) : _M_den; } friend bool operator==(const param_type& __p1, const param_type& __p2) { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; } friend bool operator!=(const param_type& __p1, const param_type& __p2) { return !(__p1 == __p2); } private: void _M_initialize(); std::vector<_RealType> _M_int; std::vector _M_den; std::vector _M_cp; std::vector _M_m; }; piecewise_linear_distribution() : _M_param() { } template piecewise_linear_distribution(_InputIteratorB __bfirst, _InputIteratorB __bend, _InputIteratorW __wbegin) : _M_param(__bfirst, __bend, __wbegin) { } template piecewise_linear_distribution(initializer_list<_RealType> __bl, _Func __fw) : _M_param(__bl, __fw) { } template piecewise_linear_distribution(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw) : _M_param(__nw, __xmin, __xmax, __fw) { } explicit piecewise_linear_distribution(const param_type& __p) : _M_param(__p) { } void reset() { } std::vector<_RealType> intervals() const { if (_M_param._M_int.empty()) { std::vector<_RealType> __tmp(2); __tmp[1] = _RealType(1); return __tmp; } else return _M_param._M_int; } std::vector densities() const { return _M_param._M_den.empty() ? std::vector(2, 1.0) : _M_param._M_den; } param_type param() const { return _M_param; } void param(const param_type& __param) { _M_param = __param; } result_type min() const { return _M_param._M_int.empty() ? result_type(0) : _M_param._M_int.front(); } result_type max() const { return _M_param._M_int.empty() ? result_type(1) : _M_param._M_int.back(); } template result_type operator()(_UniformRandomNumberGenerator& __urng) { return this->operator()(__urng, _M_param); } template result_type operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p); template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { this->__generate(__f, __t, __urng, _M_param); } template void __generate(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } template void __generate(result_type* __f, result_type* __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { this->__generate_impl(__f, __t, __urng, __p); } friend bool operator==(const piecewise_linear_distribution& __d1, const piecewise_linear_distribution& __d2) { return __d1._M_param == __d2._M_param; } # 6006 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const std::piecewise_linear_distribution<_RealType1>& __x); # 6022 "/usr/include/c++/10/bits/random.h" 3 template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, std::piecewise_linear_distribution<_RealType1>& __x); private: template void __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p); param_type _M_param; }; template inline bool operator!=(const std::piecewise_linear_distribution<_RealType>& __d1, const std::piecewise_linear_distribution<_RealType>& __d2) { return !(__d1 == __d2); } # 6063 "/usr/include/c++/10/bits/random.h" 3 class seed_seq { public: typedef uint_least32_t result_type; seed_seq() noexcept : _M_v() { } template seed_seq(std::initializer_list<_IntType> __il); template seed_seq(_InputIterator __begin, _InputIterator __end); template void generate(_RandomAccessIterator __begin, _RandomAccessIterator __end); size_t size() const noexcept { return _M_v.size(); } template void param(_OutputIterator __dest) const { std::copy(_M_v.begin(), _M_v.end(), __dest); } seed_seq(const seed_seq&) = delete; seed_seq& operator=(const seed_seq&) = delete; private: std::vector _M_v; }; } # 50 "/usr/include/c++/10/random" 2 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/opt_random.h" 1 3 # 38 "/usr/include/x86_64-linux-gnu/c++/10/bits/opt_random.h" 3 # 39 "/usr/include/x86_64-linux-gnu/c++/10/bits/opt_random.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 217 "/usr/include/x86_64-linux-gnu/c++/10/bits/opt_random.h" 3 } # 51 "/usr/include/c++/10/random" 2 3 # 1 "/usr/include/c++/10/bits/random.tcc" 1 3 # 35 "/usr/include/c++/10/bits/random.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template _Tp _Mod<_Tp, __m, __a, __c, false, true>:: __calc(_Tp __x) { if (__a == 1) __x %= __m; else { static const _Tp __q = __m / __a; static const _Tp __r = __m % __a; _Tp __t1 = __a * (__x % __q); _Tp __t2 = __r * (__x / __q); if (__t1 >= __t2) __x = __t1 - __t2; else __x = __m - __t2 + __t1; } if (__c != 0) { const _Tp __d = __m - __x; if (__d > __c) __x += __c; else __x = __c - __d; } return __x; } template _OutputIterator __normalize(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __factor) { for (; __first != __last; ++__first, ++__result) *__result = *__first / __factor; return __result; } } template constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier; template constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::increment; template constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::modulus; template constexpr _UIntType linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed; template void linear_congruential_engine<_UIntType, __a, __c, __m>:: seed(result_type __s) { if ((__detail::__mod<_UIntType, __m>(__c) == 0) && (__detail::__mod<_UIntType, __m>(__s) == 0)) _M_x = 1; else _M_x = __detail::__mod<_UIntType, __m>(__s); } template template auto linear_congruential_engine<_UIntType, __a, __c, __m>:: seed(_Sseq& __q) -> _If_seed_seq<_Sseq> { const _UIntType __k0 = __m == 0 ? std::numeric_limits<_UIntType>::digits : std::__lg(__m); const _UIntType __k = (__k0 + 31) / 32; uint_least32_t __arr[__k + 3]; __q.generate(__arr + 0, __arr + __k + 3); _UIntType __factor = 1u; _UIntType __sum = 0u; for (size_t __j = 0; __j < __k; ++__j) { __sum += __arr[__j + 3] * __factor; __factor *= __detail::_Shift<_UIntType, 32>::__value; } seed(__sum); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__os.widen(' ')); __os << __lcr._M_x; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec); __is >> __lcr._M_x; __is.flags(__flags); return __is; } template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size; template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size; template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size; template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits; template constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask; template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u; template constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d; template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s; template constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b; template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t; template constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c; template constexpr size_t mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l; template constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>:: initialization_multiplier; template constexpr _UIntType mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed; template void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>:: seed(result_type __sd) { _M_x[0] = __detail::__mod<_UIntType, __detail::_Shift<_UIntType, __w>::__value>(__sd); for (size_t __i = 1; __i < state_size; ++__i) { _UIntType __x = _M_x[__i - 1]; __x ^= __x >> (__w - 2); __x *= __f; __x += __detail::__mod<_UIntType, __n>(__i); _M_x[__i] = __detail::__mod<_UIntType, __detail::_Shift<_UIntType, __w>::__value>(__x); } _M_p = state_size; } template template auto mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>:: seed(_Sseq& __q) -> _If_seed_seq<_Sseq> { const _UIntType __upper_mask = (~_UIntType()) << __r; const size_t __k = (__w + 31) / 32; uint_least32_t __arr[__n * __k]; __q.generate(__arr + 0, __arr + __n * __k); bool __zero = true; for (size_t __i = 0; __i < state_size; ++__i) { _UIntType __factor = 1u; _UIntType __sum = 0u; for (size_t __j = 0; __j < __k; ++__j) { __sum += __arr[__k * __i + __j] * __factor; __factor *= __detail::_Shift<_UIntType, 32>::__value; } _M_x[__i] = __detail::__mod<_UIntType, __detail::_Shift<_UIntType, __w>::__value>(__sum); if (__zero) { if (__i == 0) { if ((_M_x[0] & __upper_mask) != 0u) __zero = false; } else if (_M_x[__i] != 0u) __zero = false; } } if (__zero) _M_x[0] = __detail::_Shift<_UIntType, __w - 1>::__value; _M_p = state_size; } template void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>:: _M_gen_rand(void) { const _UIntType __upper_mask = (~_UIntType()) << __r; const _UIntType __lower_mask = ~__upper_mask; for (size_t __k = 0; __k < (__n - __m); ++__k) { _UIntType __y = ((_M_x[__k] & __upper_mask) | (_M_x[__k + 1] & __lower_mask)); _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1) ^ ((__y & 0x01) ? __a : 0)); } for (size_t __k = (__n - __m); __k < (__n - 1); ++__k) { _UIntType __y = ((_M_x[__k] & __upper_mask) | (_M_x[__k + 1] & __lower_mask)); _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1) ^ ((__y & 0x01) ? __a : 0)); } _UIntType __y = ((_M_x[__n - 1] & __upper_mask) | (_M_x[0] & __lower_mask)); _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1) ^ ((__y & 0x01) ? __a : 0)); _M_p = 0; } template void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>:: discard(unsigned long long __z) { while (__z > state_size - _M_p) { __z -= state_size - _M_p; _M_gen_rand(); } _M_p += __z; } template typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>:: operator()() { if (_M_p >= state_size) _M_gen_rand(); result_type __z = _M_x[_M_p++]; __z ^= (__z >> __u) & __d; __z ^= (__z << __s) & __b; __z ^= (__z << __t) & __c; __z ^= (__z >> __l); return __z; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); for (size_t __i = 0; __i < __n; ++__i) __os << __x._M_x[__i] << __space; __os << __x._M_p; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); for (size_t __i = 0; __i < __n; ++__i) __is >> __x._M_x[__i]; __is >> __x._M_p; __is.flags(__flags); return __is; } template constexpr size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size; template constexpr size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag; template constexpr size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag; template constexpr _UIntType subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed; template void subtract_with_carry_engine<_UIntType, __w, __s, __r>:: seed(result_type __value) { std::linear_congruential_engine __lcg(__value == 0u ? default_seed : __value); const size_t __n = (__w + 31) / 32; for (size_t __i = 0; __i < long_lag; ++__i) { _UIntType __sum = 0u; _UIntType __factor = 1u; for (size_t __j = 0; __j < __n; ++__j) { __sum += __detail::__mod::__value> (__lcg()) * __factor; __factor *= __detail::_Shift<_UIntType, 32>::__value; } _M_x[__i] = __detail::__mod<_UIntType, __detail::_Shift<_UIntType, __w>::__value>(__sum); } _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0; _M_p = 0; } template template auto subtract_with_carry_engine<_UIntType, __w, __s, __r>:: seed(_Sseq& __q) -> _If_seed_seq<_Sseq> { const size_t __k = (__w + 31) / 32; uint_least32_t __arr[__r * __k]; __q.generate(__arr + 0, __arr + __r * __k); for (size_t __i = 0; __i < long_lag; ++__i) { _UIntType __sum = 0u; _UIntType __factor = 1u; for (size_t __j = 0; __j < __k; ++__j) { __sum += __arr[__k * __i + __j] * __factor; __factor *= __detail::_Shift<_UIntType, 32>::__value; } _M_x[__i] = __detail::__mod<_UIntType, __detail::_Shift<_UIntType, __w>::__value>(__sum); } _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0; _M_p = 0; } template typename subtract_with_carry_engine<_UIntType, __w, __s, __r>:: result_type subtract_with_carry_engine<_UIntType, __w, __s, __r>:: operator()() { long __ps = _M_p - short_lag; if (__ps < 0) __ps += long_lag; _UIntType __xi; if (_M_x[__ps] >= _M_x[_M_p] + _M_carry) { __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry; _M_carry = 0; } else { __xi = (__detail::_Shift<_UIntType, __w>::__value - _M_x[_M_p] - _M_carry + _M_x[__ps]); _M_carry = 1; } _M_x[_M_p] = __xi; if (++_M_p >= long_lag) _M_p = 0; return __xi; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); for (size_t __i = 0; __i < __r; ++__i) __os << __x._M_x[__i] << __space; __os << __x._M_carry << __space << __x._M_p; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); for (size_t __i = 0; __i < __r; ++__i) __is >> __x._M_x[__i]; __is >> __x._M_carry; __is >> __x._M_p; __is.flags(__flags); return __is; } template constexpr size_t discard_block_engine<_RandomNumberEngine, __p, __r>::block_size; template constexpr size_t discard_block_engine<_RandomNumberEngine, __p, __r>::used_block; template typename discard_block_engine<_RandomNumberEngine, __p, __r>::result_type discard_block_engine<_RandomNumberEngine, __p, __r>:: operator()() { if (_M_n >= used_block) { _M_b.discard(block_size - _M_n); _M_n = 0; } ++_M_n; return _M_b(); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const discard_block_engine<_RandomNumberEngine, __p, __r>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); __os << __x.base() << __space << __x._M_n; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, discard_block_engine<_RandomNumberEngine, __p, __r>& __x) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); __is >> __x._M_b >> __x._M_n; __is.flags(__flags); return __is; } template typename independent_bits_engine<_RandomNumberEngine, __w, _UIntType>:: result_type independent_bits_engine<_RandomNumberEngine, __w, _UIntType>:: operator()() { typedef typename _RandomNumberEngine::result_type _Eresult_type; const _Eresult_type __r = (_M_b.max() - _M_b.min() < std::numeric_limits<_Eresult_type>::max() ? _M_b.max() - _M_b.min() + 1 : 0); const unsigned __edig = std::numeric_limits<_Eresult_type>::digits; const unsigned __m = __r ? std::__lg(__r) : __edig; typedef typename std::common_type<_Eresult_type, result_type>::type __ctype; const unsigned __cdig = std::numeric_limits<__ctype>::digits; unsigned __n, __n0; __ctype __s0, __s1, __y0, __y1; for (size_t __i = 0; __i < 2; ++__i) { __n = (__w + __m - 1) / __m + __i; __n0 = __n - __w % __n; const unsigned __w0 = __w / __n; __s0 = 0; __s1 = 0; if (__w0 < __cdig) { __s0 = __ctype(1) << __w0; __s1 = __s0 << 1; } __y0 = 0; __y1 = 0; if (__r) { __y0 = __s0 * (__r / __s0); if (__s1) __y1 = __s1 * (__r / __s1); if (__r - __y0 <= __y0 / __n) break; } else break; } result_type __sum = 0; for (size_t __k = 0; __k < __n0; ++__k) { __ctype __u; do __u = _M_b() - _M_b.min(); while (__y0 && __u >= __y0); __sum = __s0 * __sum + (__s0 ? __u % __s0 : __u); } for (size_t __k = __n0; __k < __n; ++__k) { __ctype __u; do __u = _M_b() - _M_b.min(); while (__y1 && __u >= __y1); __sum = __s1 * __sum + (__s1 ? __u % __s1 : __u); } return __sum; } template constexpr size_t shuffle_order_engine<_RandomNumberEngine, __k>::table_size; template typename shuffle_order_engine<_RandomNumberEngine, __k>::result_type shuffle_order_engine<_RandomNumberEngine, __k>:: operator()() { size_t __j = __k * ((_M_y - _M_b.min()) / (_M_b.max() - _M_b.min() + 1.0L)); _M_y = _M_v[__j]; _M_v[__j] = _M_b(); return _M_y; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const shuffle_order_engine<_RandomNumberEngine, __k>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); __os.fill(__space); __os << __x.base(); for (size_t __i = 0; __i < __k; ++__i) __os << __space << __x._M_v[__i]; __os << __space << __x._M_y; __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, shuffle_order_engine<_RandomNumberEngine, __k>& __x) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); __is >> __x._M_b; for (size_t __i = 0; __i < __k; ++__i) __is >> __x._M_v[__i]; __is >> __x._M_y; __is.flags(__flags); return __is; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uniform_int_distribution<_IntType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os << __x.a() << __space << __x.b(); __os.flags(__flags); __os.fill(__fill); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, uniform_int_distribution<_IntType>& __x) { using param_type = typename uniform_int_distribution<_IntType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _IntType __a, __b; if (__is >> __a >> __b) __x.param(param_type(__a, __b)); __is.flags(__flags); return __is; } template template void uniform_real_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); auto __range = __p.b() - __p.a(); while (__f != __t) *__f++ = __aurng() * __range + __p.a(); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const uniform_real_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.a() << __space << __x.b(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, uniform_real_distribution<_RealType>& __x) { using param_type = typename uniform_real_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::skipws); _RealType __a, __b; if (__is >> __a >> __b) __x.param(param_type(__a, __b)); __is.flags(__flags); return __is; } template void std::bernoulli_distribution:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); auto __limit = __p.p() * (__aurng.max() - __aurng.min()); while (__f != __t) *__f++ = (__aurng() - __aurng.min()) < __limit; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(std::numeric_limits::max_digits10); __os << __x.p(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template template typename geometric_distribution<_IntType>::result_type geometric_distribution<_IntType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { const double __naf = (1 - std::numeric_limits::epsilon()) / 2; const double __thr = std::numeric_limits<_IntType>::max() + __naf; __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); double __cand; do __cand = std::floor(std::log(1.0 - __aurng()) / __param._M_log_1_p); while (__cand >= __thr); return result_type(__cand + __naf); } template template void geometric_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { const double __naf = (1 - std::numeric_limits::epsilon()) / 2; const double __thr = std::numeric_limits<_IntType>::max() + __naf; __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); while (__f != __t) { double __cand; do __cand = std::floor(std::log(1.0 - __aurng()) / __param._M_log_1_p); while (__cand >= __thr); *__f++ = __cand + __naf; } } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const geometric_distribution<_IntType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(std::numeric_limits::max_digits10); __os << __x.p(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, geometric_distribution<_IntType>& __x) { using param_type = typename geometric_distribution<_IntType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::skipws); double __p; if (__is >> __p) __x.param(param_type(__p)); __is.flags(__flags); return __is; } template template typename negative_binomial_distribution<_IntType>::result_type negative_binomial_distribution<_IntType>:: operator()(_UniformRandomNumberGenerator& __urng) { const double __y = _M_gd(__urng); std::poisson_distribution __poisson(__y); return __poisson(__urng); } template template typename negative_binomial_distribution<_IntType>::result_type negative_binomial_distribution<_IntType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { typedef typename std::gamma_distribution::param_type param_type; const double __y = _M_gd(__urng, param_type(__p.k(), (1.0 - __p.p()) / __p.p())); std::poisson_distribution __poisson(__y); return __poisson(__urng); } template template void negative_binomial_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { while (__f != __t) { const double __y = _M_gd(__urng); std::poisson_distribution __poisson(__y); *__f++ = __poisson(__urng); } } template template void negative_binomial_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { typename std::gamma_distribution::param_type __p2(__p.k(), (1.0 - __p.p()) / __p.p()); while (__f != __t) { const double __y = _M_gd(__urng, __p2); std::poisson_distribution __poisson(__y); *__f++ = __poisson(__urng); } } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const negative_binomial_distribution<_IntType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(std::numeric_limits::max_digits10); __os << __x.k() << __space << __x.p() << __space << __x._M_gd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, negative_binomial_distribution<_IntType>& __x) { using param_type = typename negative_binomial_distribution<_IntType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::skipws); _IntType __k; double __p; if (__is >> __k >> __p >> __x._M_gd) __x.param(param_type(__k, __p)); __is.flags(__flags); return __is; } template void poisson_distribution<_IntType>::param_type:: _M_initialize() { if (_M_mean >= 12) { const double __m = std::floor(_M_mean); _M_lm_thr = std::log(_M_mean); _M_lfm = std::lgamma(__m + 1); _M_sm = std::sqrt(__m); const double __pi_4 = 0.7853981633974483096156608458198757L; const double __dx = std::sqrt(2 * __m * std::log(32 * __m / __pi_4)); _M_d = std::round(std::max(6.0, std::min(__m, __dx))); const double __cx = 2 * __m + _M_d; _M_scx = std::sqrt(__cx / 2); _M_1cx = 1 / __cx; _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx); _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2)) / _M_d; } else _M_lm_thr = std::exp(-_M_mean); } # 1265 "/usr/include/c++/10/bits/random.tcc" 3 template template typename poisson_distribution<_IntType>::result_type poisson_distribution<_IntType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); if (__param.mean() >= 12) { double __x; const double __naf = (1 - std::numeric_limits::epsilon()) / 2; const double __thr = std::numeric_limits<_IntType>::max() + __naf; const double __m = std::floor(__param.mean()); const double __spi_2 = 1.2533141373155002512078826424055226L; const double __c1 = __param._M_sm * __spi_2; const double __c2 = __param._M_c2b + __c1; const double __c3 = __c2 + 1; const double __c4 = __c3 + 1; const double __178 = 0.0128205128205128205128205128205128L; const double __e178 = 1.0129030479320018583185514777512983L; const double __c5 = __c4 + __e178; const double __c = __param._M_cb + __c5; const double __2cx = 2 * (2 * __m + __param._M_d); bool __reject = true; do { const double __u = __c * __aurng(); const double __e = -std::log(1.0 - __aurng()); double __w = 0.0; if (__u <= __c1) { const double __n = _M_nd(__urng); const double __y = -std::abs(__n) * __param._M_sm - 1; __x = std::floor(__y); __w = -__n * __n / 2; if (__x < -__m) continue; } else if (__u <= __c2) { const double __n = _M_nd(__urng); const double __y = 1 + std::abs(__n) * __param._M_scx; __x = std::ceil(__y); __w = __y * (2 - __y) * __param._M_1cx; if (__x > __param._M_d) continue; } else if (__u <= __c3) __x = -1; else if (__u <= __c4) __x = 0; else if (__u <= __c5) { __x = 1; __w = __178; } else { const double __v = -std::log(1.0 - __aurng()); const double __y = __param._M_d + __v * __2cx / __param._M_d; __x = std::ceil(__y); __w = -__param._M_d * __param._M_1cx * (1 + __y / 2); } __reject = (__w - __e - __x * __param._M_lm_thr > __param._M_lfm - std::lgamma(__x + __m + 1)); __reject |= __x + __m >= __thr; } while (__reject); return result_type(__x + __m + __naf); } else { _IntType __x = 0; double __prod = 1.0; do { __prod *= __aurng(); __x += 1; } while (__prod > __param._M_lm_thr); return __x - 1; } } template template void poisson_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { while (__f != __t) *__f++ = this->operator()(__urng, __param); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const poisson_distribution<_IntType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits::max_digits10); __os << __x.mean() << __space << __x._M_nd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, poisson_distribution<_IntType>& __x) { using param_type = typename poisson_distribution<_IntType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::skipws); double __mean; if (__is >> __mean >> __x._M_nd) __x.param(param_type(__mean)); __is.flags(__flags); return __is; } template void binomial_distribution<_IntType>::param_type:: _M_initialize() { const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p; _M_easy = true; if (_M_t * __p12 >= 8) { _M_easy = false; const double __np = std::floor(_M_t * __p12); const double __pa = __np / _M_t; const double __1p = 1 - __pa; const double __pi_4 = 0.7853981633974483096156608458198757L; const double __d1x = std::sqrt(__np * __1p * std::log(32 * __np / (81 * __pi_4 * __1p))); _M_d1 = std::round(std::max(1.0, __d1x)); const double __d2x = std::sqrt(__np * __1p * std::log(32 * _M_t * __1p / (__pi_4 * __pa))); _M_d2 = std::round(std::max(1.0, __d2x)); const double __spi_2 = 1.2533141373155002512078826424055226L; _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np)); _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p)); _M_c = 2 * _M_d1 / __np; _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2; const double __a12 = _M_a1 + _M_s2 * __spi_2; const double __s1s = _M_s1 * _M_s1; _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p)) * 2 * __s1s / _M_d1 * std::exp(-_M_d1 * _M_d1 / (2 * __s1s))); const double __s2s = _M_s2 * _M_s2; _M_s = (_M_a123 + 2 * __s2s / _M_d2 * std::exp(-_M_d2 * _M_d2 / (2 * __s2s))); _M_lf = (std::lgamma(__np + 1) + std::lgamma(_M_t - __np + 1)); _M_lp1p = std::log(__pa / __1p); _M_q = -std::log(1 - (__p12 - __pa) / __1p); } else _M_q = -std::log(1 - __p12); } template template typename binomial_distribution<_IntType>::result_type binomial_distribution<_IntType>:: _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t, double __q) { _IntType __x = 0; double __sum = 0.0; __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); do { if (__t == __x) return __x; const double __e = -std::log(1.0 - __aurng()); __sum += __e / (__t - __x); __x += 1; } while (__sum <= __q); return __x - 1; } # 1520 "/usr/include/c++/10/bits/random.tcc" 3 template template typename binomial_distribution<_IntType>::result_type binomial_distribution<_IntType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { result_type __ret; const _IntType __t = __param.t(); const double __p = __param.p(); const double __p12 = __p <= 0.5 ? __p : 1.0 - __p; __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); if (!__param._M_easy) { double __x; const double __naf = (1 - std::numeric_limits::epsilon()) / 2; const double __thr = std::numeric_limits<_IntType>::max() + __naf; const double __np = std::floor(__t * __p12); const double __spi_2 = 1.2533141373155002512078826424055226L; const double __a1 = __param._M_a1; const double __a12 = __a1 + __param._M_s2 * __spi_2; const double __a123 = __param._M_a123; const double __s1s = __param._M_s1 * __param._M_s1; const double __s2s = __param._M_s2 * __param._M_s2; bool __reject; do { const double __u = __param._M_s * __aurng(); double __v; if (__u <= __a1) { const double __n = _M_nd(__urng); const double __y = __param._M_s1 * std::abs(__n); __reject = __y >= __param._M_d1; if (!__reject) { const double __e = -std::log(1.0 - __aurng()); __x = std::floor(__y); __v = -__e - __n * __n / 2 + __param._M_c; } } else if (__u <= __a12) { const double __n = _M_nd(__urng); const double __y = __param._M_s2 * std::abs(__n); __reject = __y >= __param._M_d2; if (!__reject) { const double __e = -std::log(1.0 - __aurng()); __x = std::floor(-__y); __v = -__e - __n * __n / 2; } } else if (__u <= __a123) { const double __e1 = -std::log(1.0 - __aurng()); const double __e2 = -std::log(1.0 - __aurng()); const double __y = __param._M_d1 + 2 * __s1s * __e1 / __param._M_d1; __x = std::floor(__y); __v = (-__e2 + __param._M_d1 * (1 / (__t - __np) -__y / (2 * __s1s))); __reject = false; } else { const double __e1 = -std::log(1.0 - __aurng()); const double __e2 = -std::log(1.0 - __aurng()); const double __y = __param._M_d2 + 2 * __s2s * __e1 / __param._M_d2; __x = std::floor(-__y); __v = -__e2 - __param._M_d2 * __y / (2 * __s2s); __reject = false; } __reject = __reject || __x < -__np || __x > __t - __np; if (!__reject) { const double __lfx = std::lgamma(__np + __x + 1) + std::lgamma(__t - (__np + __x) + 1); __reject = __v > __param._M_lf - __lfx + __x * __param._M_lp1p; } __reject |= __x + __np >= __thr; } while (__reject); __x += __np + __naf; const _IntType __z = _M_waiting(__urng, __t - _IntType(__x), __param._M_q); __ret = _IntType(__x) + __z; } else __ret = _M_waiting(__urng, __t, __param._M_q); if (__p12 != __p) __ret = __t - __ret; return __ret; } template template void binomial_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { while (__f != __t) *__f++ = this->operator()(__urng, __param); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const binomial_distribution<_IntType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits::max_digits10); __os << __x.t() << __space << __x.p() << __space << __x._M_nd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, binomial_distribution<_IntType>& __x) { using param_type = typename binomial_distribution<_IntType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _IntType __t; double __p; if (__is >> __t >> __p >> __x._M_nd) __x.param(param_type(__t, __p)); __is.flags(__flags); return __is; } template template void std::exponential_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); while (__f != __t) *__f++ = -std::log(result_type(1) - __aurng()) / __p.lambda(); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const exponential_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__os.widen(' ')); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.lambda(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, exponential_distribution<_RealType>& __x) { using param_type = typename exponential_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __lambda; if (__is >> __lambda) __x.param(param_type(__lambda)); __is.flags(__flags); return __is; } # 1766 "/usr/include/c++/10/bits/random.tcc" 3 template template typename normal_distribution<_RealType>::result_type normal_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { result_type __ret; __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); if (_M_saved_available) { _M_saved_available = false; __ret = _M_saved; } else { result_type __x, __y, __r2; do { __x = result_type(2.0) * __aurng() - 1.0; __y = result_type(2.0) * __aurng() - 1.0; __r2 = __x * __x + __y * __y; } while (__r2 > 1.0 || __r2 == 0.0); const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); _M_saved = __x * __mult; _M_saved_available = true; __ret = __y * __mult; } __ret = __ret * __param.stddev() + __param.mean(); return __ret; } template template void normal_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { if (__f == __t) return; if (_M_saved_available) { _M_saved_available = false; *__f++ = _M_saved * __param.stddev() + __param.mean(); if (__f == __t) return; } __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); while (__f + 1 < __t) { result_type __x, __y, __r2; do { __x = result_type(2.0) * __aurng() - 1.0; __y = result_type(2.0) * __aurng() - 1.0; __r2 = __x * __x + __y * __y; } while (__r2 > 1.0 || __r2 == 0.0); const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); *__f++ = __y * __mult * __param.stddev() + __param.mean(); *__f++ = __x * __mult * __param.stddev() + __param.mean(); } if (__f != __t) { result_type __x, __y, __r2; do { __x = result_type(2.0) * __aurng() - 1.0; __y = result_type(2.0) * __aurng() - 1.0; __r2 = __x * __x + __y * __y; } while (__r2 > 1.0 || __r2 == 0.0); const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); _M_saved = __x * __mult; _M_saved_available = true; *__f = __y * __mult * __param.stddev() + __param.mean(); } } template bool operator==(const std::normal_distribution<_RealType>& __d1, const std::normal_distribution<_RealType>& __d2) { if (__d1._M_param == __d2._M_param && __d1._M_saved_available == __d2._M_saved_available) { if (__d1._M_saved_available && __d1._M_saved == __d2._M_saved) return true; else if(!__d1._M_saved_available) return true; else return false; } else return false; } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const normal_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.mean() << __space << __x.stddev() << __space << __x._M_saved_available; if (__x._M_saved_available) __os << __space << __x._M_saved; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, normal_distribution<_RealType>& __x) { using param_type = typename normal_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); double __mean, __stddev; bool __saved_avail; if (__is >> __mean >> __stddev >> __saved_avail) { if (__saved_avail && (__is >> __x._M_saved)) { __x._M_saved_available = __saved_avail; __x.param(param_type(__mean, __stddev)); } } __is.flags(__flags); return __is; } template template void lognormal_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { while (__f != __t) *__f++ = std::exp(__p.s() * _M_nd(__urng) + __p.m()); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const lognormal_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.m() << __space << __x.s() << __space << __x._M_nd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, lognormal_distribution<_RealType>& __x) { using param_type = typename lognormal_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __m, __s; if (__is >> __m >> __s >> __x._M_nd) __x.param(param_type(__m, __s)); __is.flags(__flags); return __is; } template template void std::chi_squared_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { while (__f != __t) *__f++ = 2 * _M_gd(__urng); } template template void std::chi_squared_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const typename std::gamma_distribution::param_type& __p) { while (__f != __t) *__f++ = 2 * _M_gd(__urng, __p); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const chi_squared_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.n() << __space << __x._M_gd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, chi_squared_distribution<_RealType>& __x) { using param_type = typename chi_squared_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __n; if (__is >> __n >> __x._M_gd) __x.param(param_type(__n)); __is.flags(__flags); return __is; } template template typename cauchy_distribution<_RealType>::result_type cauchy_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); _RealType __u; do __u = __aurng(); while (__u == 0.5); const _RealType __pi = 3.1415926535897932384626433832795029L; return __p.a() + __p.b() * std::tan(__pi * __u); } template template void cauchy_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { const _RealType __pi = 3.1415926535897932384626433832795029L; __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); while (__f != __t) { _RealType __u; do __u = __aurng(); while (__u == 0.5); *__f++ = __p.a() + __p.b() * std::tan(__pi * __u); } } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const cauchy_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.a() << __space << __x.b(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, cauchy_distribution<_RealType>& __x) { using param_type = typename cauchy_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __a, __b; if (__is >> __a >> __b) __x.param(param_type(__a, __b)); __is.flags(__flags); return __is; } template template void std::fisher_f_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { while (__f != __t) *__f++ = ((_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m())); } template template void std::fisher_f_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { typedef typename std::gamma_distribution::param_type param_type; param_type __p1(__p.m() / 2); param_type __p2(__p.n() / 2); while (__f != __t) *__f++ = ((_M_gd_x(__urng, __p1) * n()) / (_M_gd_y(__urng, __p2) * m())); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const fisher_f_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.m() << __space << __x.n() << __space << __x._M_gd_x << __space << __x._M_gd_y; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, fisher_f_distribution<_RealType>& __x) { using param_type = typename fisher_f_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __m, __n; if (__is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y) __x.param(param_type(__m, __n)); __is.flags(__flags); return __is; } template template void std::student_t_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng) { while (__f != __t) *__f++ = _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); } template template void std::student_t_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { typename std::gamma_distribution::param_type __p2(__p.n() / 2, 2); while (__f != __t) *__f++ = _M_nd(__urng) * std::sqrt(__p.n() / _M_gd(__urng, __p2)); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const student_t_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.n() << __space << __x._M_nd << __space << __x._M_gd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, student_t_distribution<_RealType>& __x) { using param_type = typename student_t_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __n; if (__is >> __n >> __x._M_nd >> __x._M_gd) __x.param(param_type(__n)); __is.flags(__flags); return __is; } template void gamma_distribution<_RealType>::param_type:: _M_initialize() { _M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType(1.0) : _M_alpha; const _RealType __a1 = _M_malpha - _RealType(1.0) / _RealType(3.0); _M_a2 = _RealType(1.0) / std::sqrt(_RealType(9.0) * __a1); } template template typename gamma_distribution<_RealType>::result_type gamma_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); result_type __u, __v, __n; const result_type __a1 = (__param._M_malpha - _RealType(1.0) / _RealType(3.0)); do { do { __n = _M_nd(__urng); __v = result_type(1.0) + __param._M_a2 * __n; } while (__v <= 0.0); __v = __v * __v * __v; __u = __aurng(); } while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n && (std::log(__u) > (0.5 * __n * __n + __a1 * (1.0 - __v + std::log(__v))))); if (__param.alpha() == __param._M_malpha) return __a1 * __v * __param.beta(); else { do __u = __aurng(); while (__u == 0.0); return (std::pow(__u, result_type(1.0) / __param.alpha()) * __a1 * __v * __param.beta()); } } template template void gamma_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); result_type __u, __v, __n; const result_type __a1 = (__param._M_malpha - _RealType(1.0) / _RealType(3.0)); if (__param.alpha() == __param._M_malpha) while (__f != __t) { do { do { __n = _M_nd(__urng); __v = result_type(1.0) + __param._M_a2 * __n; } while (__v <= 0.0); __v = __v * __v * __v; __u = __aurng(); } while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n && (std::log(__u) > (0.5 * __n * __n + __a1 * (1.0 - __v + std::log(__v))))); *__f++ = __a1 * __v * __param.beta(); } else while (__f != __t) { do { do { __n = _M_nd(__urng); __v = result_type(1.0) + __param._M_a2 * __n; } while (__v <= 0.0); __v = __v * __v * __v; __u = __aurng(); } while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n && (std::log(__u) > (0.5 * __n * __n + __a1 * (1.0 - __v + std::log(__v))))); do __u = __aurng(); while (__u == 0.0); *__f++ = (std::pow(__u, result_type(1.0) / __param.alpha()) * __a1 * __v * __param.beta()); } } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const gamma_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.alpha() << __space << __x.beta() << __space << __x._M_nd; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, gamma_distribution<_RealType>& __x) { using param_type = typename gamma_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __alpha_val, __beta_val; if (__is >> __alpha_val >> __beta_val >> __x._M_nd) __x.param(param_type(__alpha_val, __beta_val)); __is.flags(__flags); return __is; } template template typename weibull_distribution<_RealType>::result_type weibull_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); return __p.b() * std::pow(-std::log(result_type(1) - __aurng()), result_type(1) / __p.a()); } template template void weibull_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); auto __inv_a = result_type(1) / __p.a(); while (__f != __t) *__f++ = __p.b() * std::pow(-std::log(result_type(1) - __aurng()), __inv_a); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const weibull_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.a() << __space << __x.b(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, weibull_distribution<_RealType>& __x) { using param_type = typename weibull_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __a, __b; if (__is >> __a >> __b) __x.param(param_type(__a, __b)); __is.flags(__flags); return __is; } template template typename extreme_value_distribution<_RealType>::result_type extreme_value_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); return __p.a() - __p.b() * std::log(-std::log(result_type(1) - __aurng())); } template template void extreme_value_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __p) { __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> __aurng(__urng); while (__f != __t) *__f++ = __p.a() - __p.b() * std::log(-std::log(result_type(1) - __aurng())); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const extreme_value_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); __os << __x.a() << __space << __x.b(); __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, extreme_value_distribution<_RealType>& __x) { using param_type = typename extreme_value_distribution<_RealType>::param_type; using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); _RealType __a, __b; if (__is >> __a >> __b) __x.param(param_type(__a, __b)); __is.flags(__flags); return __is; } template void discrete_distribution<_IntType>::param_type:: _M_initialize() { if (_M_prob.size() < 2) { _M_prob.clear(); return; } const double __sum = std::accumulate(_M_prob.begin(), _M_prob.end(), 0.0); ; __detail::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(), __sum); _M_cp.reserve(_M_prob.size()); std::partial_sum(_M_prob.begin(), _M_prob.end(), std::back_inserter(_M_cp)); _M_cp[_M_cp.size() - 1] = 1.0; } template template discrete_distribution<_IntType>::param_type:: param_type(size_t __nw, double __xmin, double __xmax, _Func __fw) : _M_prob(), _M_cp() { const size_t __n = __nw == 0 ? 1 : __nw; const double __delta = (__xmax - __xmin) / __n; _M_prob.reserve(__n); for (size_t __k = 0; __k < __nw; ++__k) _M_prob.push_back(__fw(__xmin + __k * __delta + 0.5 * __delta)); _M_initialize(); } template template typename discrete_distribution<_IntType>::result_type discrete_distribution<_IntType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { if (__param._M_cp.empty()) return result_type(0); __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); const double __p = __aurng(); auto __pos = std::lower_bound(__param._M_cp.begin(), __param._M_cp.end(), __p); return __pos - __param._M_cp.begin(); } template template void discrete_distribution<_IntType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { if (__param._M_cp.empty()) { while (__f != __t) *__f++ = result_type(0); return; } __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); while (__f != __t) { const double __p = __aurng(); auto __pos = std::lower_bound(__param._M_cp.begin(), __param._M_cp.end(), __p); *__f++ = __pos - __param._M_cp.begin(); } } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const discrete_distribution<_IntType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits::max_digits10); std::vector __prob = __x.probabilities(); __os << __prob.size(); for (auto __dit = __prob.begin(); __dit != __prob.end(); ++__dit) __os << __space << *__dit; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } namespace __detail { template basic_istream<_CharT, _Traits>& __extract_params(basic_istream<_CharT, _Traits>& __is, vector<_ValT>& __vals, size_t __n) { __vals.reserve(__n); while (__n--) { _ValT __val; if (__is >> __val) __vals.push_back(__val); else break; } return __is; } } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, discrete_distribution<_IntType>& __x) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); size_t __n; if (__is >> __n) { std::vector __prob_vec; if (__detail::__extract_params(__is, __prob_vec, __n)) __x.param({__prob_vec.begin(), __prob_vec.end()}); } __is.flags(__flags); return __is; } template void piecewise_constant_distribution<_RealType>::param_type:: _M_initialize() { if (_M_int.size() < 2 || (_M_int.size() == 2 && _M_int[0] == _RealType(0) && _M_int[1] == _RealType(1))) { _M_int.clear(); _M_den.clear(); return; } const double __sum = std::accumulate(_M_den.begin(), _M_den.end(), 0.0); ; __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(), __sum); _M_cp.reserve(_M_den.size()); std::partial_sum(_M_den.begin(), _M_den.end(), std::back_inserter(_M_cp)); _M_cp[_M_cp.size() - 1] = 1.0; for (size_t __k = 0; __k < _M_den.size(); ++__k) _M_den[__k] /= _M_int[__k + 1] - _M_int[__k]; } template template piecewise_constant_distribution<_RealType>::param_type:: param_type(_InputIteratorB __bbegin, _InputIteratorB __bend, _InputIteratorW __wbegin) : _M_int(), _M_den(), _M_cp() { if (__bbegin != __bend) { for (;;) { _M_int.push_back(*__bbegin); ++__bbegin; if (__bbegin == __bend) break; _M_den.push_back(*__wbegin); ++__wbegin; } } _M_initialize(); } template template piecewise_constant_distribution<_RealType>::param_type:: param_type(initializer_list<_RealType> __bl, _Func __fw) : _M_int(), _M_den(), _M_cp() { _M_int.reserve(__bl.size()); for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter) _M_int.push_back(*__biter); _M_den.reserve(_M_int.size() - 1); for (size_t __k = 0; __k < _M_int.size() - 1; ++__k) _M_den.push_back(__fw(0.5 * (_M_int[__k + 1] + _M_int[__k]))); _M_initialize(); } template template piecewise_constant_distribution<_RealType>::param_type:: param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw) : _M_int(), _M_den(), _M_cp() { const size_t __n = __nw == 0 ? 1 : __nw; const _RealType __delta = (__xmax - __xmin) / __n; _M_int.reserve(__n + 1); for (size_t __k = 0; __k <= __nw; ++__k) _M_int.push_back(__xmin + __k * __delta); _M_den.reserve(__n); for (size_t __k = 0; __k < __nw; ++__k) _M_den.push_back(__fw(_M_int[__k] + 0.5 * __delta)); _M_initialize(); } template template typename piecewise_constant_distribution<_RealType>::result_type piecewise_constant_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); const double __p = __aurng(); if (__param._M_cp.empty()) return __p; auto __pos = std::lower_bound(__param._M_cp.begin(), __param._M_cp.end(), __p); const size_t __i = __pos - __param._M_cp.begin(); const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0; return __param._M_int[__i] + (__p - __pref) / __param._M_den[__i]; } template template void piecewise_constant_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); if (__param._M_cp.empty()) { while (__f != __t) *__f++ = __aurng(); return; } while (__f != __t) { const double __p = __aurng(); auto __pos = std::lower_bound(__param._M_cp.begin(), __param._M_cp.end(), __p); const size_t __i = __pos - __param._M_cp.begin(); const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0; *__f++ = (__param._M_int[__i] + (__p - __pref) / __param._M_den[__i]); } } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const piecewise_constant_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); std::vector<_RealType> __int = __x.intervals(); __os << __int.size() - 1; for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit) __os << __space << *__xit; std::vector __den = __x.densities(); for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit) __os << __space << *__dit; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, piecewise_constant_distribution<_RealType>& __x) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); size_t __n; if (__is >> __n) { std::vector<_RealType> __int_vec; if (__detail::__extract_params(__is, __int_vec, __n + 1)) { std::vector __den_vec; if (__detail::__extract_params(__is, __den_vec, __n)) { __x.param({ __int_vec.begin(), __int_vec.end(), __den_vec.begin() }); } } } __is.flags(__flags); return __is; } template void piecewise_linear_distribution<_RealType>::param_type:: _M_initialize() { if (_M_int.size() < 2 || (_M_int.size() == 2 && _M_int[0] == _RealType(0) && _M_int[1] == _RealType(1) && _M_den[0] == _M_den[1])) { _M_int.clear(); _M_den.clear(); return; } double __sum = 0.0; _M_cp.reserve(_M_int.size() - 1); _M_m.reserve(_M_int.size() - 1); for (size_t __k = 0; __k < _M_int.size() - 1; ++__k) { const _RealType __delta = _M_int[__k + 1] - _M_int[__k]; __sum += 0.5 * (_M_den[__k + 1] + _M_den[__k]) * __delta; _M_cp.push_back(__sum); _M_m.push_back((_M_den[__k + 1] - _M_den[__k]) / __delta); } ; __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(), __sum); __detail::__normalize(_M_cp.begin(), _M_cp.end(), _M_cp.begin(), __sum); __detail::__normalize(_M_m.begin(), _M_m.end(), _M_m.begin(), __sum); _M_cp[_M_cp.size() - 1] = 1.0; } template template piecewise_linear_distribution<_RealType>::param_type:: param_type(_InputIteratorB __bbegin, _InputIteratorB __bend, _InputIteratorW __wbegin) : _M_int(), _M_den(), _M_cp(), _M_m() { for (; __bbegin != __bend; ++__bbegin, ++__wbegin) { _M_int.push_back(*__bbegin); _M_den.push_back(*__wbegin); } _M_initialize(); } template template piecewise_linear_distribution<_RealType>::param_type:: param_type(initializer_list<_RealType> __bl, _Func __fw) : _M_int(), _M_den(), _M_cp(), _M_m() { _M_int.reserve(__bl.size()); _M_den.reserve(__bl.size()); for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter) { _M_int.push_back(*__biter); _M_den.push_back(__fw(*__biter)); } _M_initialize(); } template template piecewise_linear_distribution<_RealType>::param_type:: param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw) : _M_int(), _M_den(), _M_cp(), _M_m() { const size_t __n = __nw == 0 ? 1 : __nw; const _RealType __delta = (__xmax - __xmin) / __n; _M_int.reserve(__n + 1); _M_den.reserve(__n + 1); for (size_t __k = 0; __k <= __nw; ++__k) { _M_int.push_back(__xmin + __k * __delta); _M_den.push_back(__fw(_M_int[__k] + __delta)); } _M_initialize(); } template template typename piecewise_linear_distribution<_RealType>::result_type piecewise_linear_distribution<_RealType>:: operator()(_UniformRandomNumberGenerator& __urng, const param_type& __param) { __detail::_Adaptor<_UniformRandomNumberGenerator, double> __aurng(__urng); const double __p = __aurng(); if (__param._M_cp.empty()) return __p; auto __pos = std::lower_bound(__param._M_cp.begin(), __param._M_cp.end(), __p); const size_t __i = __pos - __param._M_cp.begin(); const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0; const double __a = 0.5 * __param._M_m[__i]; const double __b = __param._M_den[__i]; const double __cm = __p - __pref; _RealType __x = __param._M_int[__i]; if (__a == 0) __x += __cm / __b; else { const double __d = __b * __b + 4.0 * __a * __cm; __x += 0.5 * (std::sqrt(__d) - __b) / __a; } return __x; } template template void piecewise_linear_distribution<_RealType>:: __generate_impl(_ForwardIterator __f, _ForwardIterator __t, _UniformRandomNumberGenerator& __urng, const param_type& __param) { while (__f != __t) *__f++ = this->operator()(__urng, __param); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const piecewise_linear_distribution<_RealType>& __x) { using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __os.flags(); const _CharT __fill = __os.fill(); const std::streamsize __precision = __os.precision(); const _CharT __space = __os.widen(' '); __os.flags(__ios_base::scientific | __ios_base::left); __os.fill(__space); __os.precision(std::numeric_limits<_RealType>::max_digits10); std::vector<_RealType> __int = __x.intervals(); __os << __int.size() - 1; for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit) __os << __space << *__xit; std::vector __den = __x.densities(); for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit) __os << __space << *__dit; __os.flags(__flags); __os.fill(__fill); __os.precision(__precision); return __os; } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, piecewise_linear_distribution<_RealType>& __x) { using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base; const typename __ios_base::fmtflags __flags = __is.flags(); __is.flags(__ios_base::dec | __ios_base::skipws); size_t __n; if (__is >> __n) { vector<_RealType> __int_vec; if (__detail::__extract_params(__is, __int_vec, __n + 1)) { vector __den_vec; if (__detail::__extract_params(__is, __den_vec, __n + 1)) { __x.param({ __int_vec.begin(), __int_vec.end(), __den_vec.begin() }); } } } __is.flags(__flags); return __is; } template seed_seq::seed_seq(std::initializer_list<_IntType> __il) { for (auto __iter = __il.begin(); __iter != __il.end(); ++__iter) _M_v.push_back(__detail::__mod::__value>(*__iter)); } template seed_seq::seed_seq(_InputIterator __begin, _InputIterator __end) { for (_InputIterator __iter = __begin; __iter != __end; ++__iter) _M_v.push_back(__detail::__mod::__value>(*__iter)); } template void seed_seq::generate(_RandomAccessIterator __begin, _RandomAccessIterator __end) { typedef typename iterator_traits<_RandomAccessIterator>::value_type _Type; if (__begin == __end) return; std::fill(__begin, __end, _Type(0x8b8b8b8bu)); const size_t __n = __end - __begin; const size_t __s = _M_v.size(); const size_t __t = (__n >= 623) ? 11 : (__n >= 68) ? 7 : (__n >= 39) ? 5 : (__n >= 7) ? 3 : (__n - 1) / 2; const size_t __p = (__n - __t) / 2; const size_t __q = __p + __t; const size_t __m = std::max(size_t(__s + 1), __n); for (size_t __k = 0; __k < __m; ++__k) { _Type __arg = (__begin[__k % __n] ^ __begin[(__k + __p) % __n] ^ __begin[(__k - 1) % __n]); _Type __r1 = __arg ^ (__arg >> 27); __r1 = __detail::__mod<_Type, __detail::_Shift<_Type, 32>::__value>(1664525u * __r1); _Type __r2 = __r1; if (__k == 0) __r2 += __s; else if (__k <= __s) __r2 += __k % __n + _M_v[__k - 1]; else __r2 += __k % __n; __r2 = __detail::__mod<_Type, __detail::_Shift<_Type, 32>::__value>(__r2); __begin[(__k + __p) % __n] += __r1; __begin[(__k + __q) % __n] += __r2; __begin[__k % __n] = __r2; } for (size_t __k = __m; __k < __m + __n; ++__k) { _Type __arg = (__begin[__k % __n] + __begin[(__k + __p) % __n] + __begin[(__k - 1) % __n]); _Type __r3 = __arg ^ (__arg >> 27); __r3 = __detail::__mod<_Type, __detail::_Shift<_Type, 32>::__value>(1566083941u * __r3); _Type __r4 = __r3 - __k % __n; __r4 = __detail::__mod<_Type, __detail::_Shift<_Type, 32>::__value>(__r4); __begin[(__k + __p) % __n] ^= __r3; __begin[(__k + __q) % __n] ^= __r4; __begin[__k % __n] = __r4; } } template _RealType generate_canonical(_UniformRandomNumberGenerator& __urng) { static_assert(std::is_floating_point<_RealType>::value, "template argument must be a floating point type"); const size_t __b = std::min(static_cast(std::numeric_limits<_RealType>::digits), __bits); const long double __r = static_cast(__urng.max()) - static_cast(__urng.min()) + 1.0L; const size_t __log2r = std::log(__r) / std::log(2.0L); const size_t __m = std::max(1UL, (__b + __log2r - 1UL) / __log2r); _RealType __ret; _RealType __sum = _RealType(0); _RealType __tmp = _RealType(1); for (size_t __k = __m; __k != 0; --__k) { __sum += _RealType(__urng() - __urng.min()) * __tmp; __tmp *= __r; } __ret = __sum / __tmp; if (__builtin_expect(__ret >= _RealType(1), 0)) { __ret = std::nextafter(_RealType(1), _RealType(0)); } return __ret; } } # 52 "/usr/include/c++/10/random" 2 3 # 78 "all-std.cxx" 2 # 1 "/usr/include/c++/10/valarray" 1 3 # 34 "/usr/include/c++/10/valarray" 3 # 35 "/usr/include/c++/10/valarray" 3 # 1 "/usr/include/c++/10/cmath" 1 3 # 39 "/usr/include/c++/10/cmath" 3 # 40 "/usr/include/c++/10/cmath" 3 # 38 "/usr/include/c++/10/valarray" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class _Expr; template class _ValArray; namespace __detail { template class _Meta, class _Dom> struct _UnClos; template class _Meta1, template class _Meta2, class _Dom1, class _Dom2> class _BinClos; template class _Meta, class _Dom> class _SClos; template class _Meta, class _Dom> class _GClos; template class _Meta, class _Dom> class _IClos; template class _Meta, class _Dom> class _ValFunClos; template class _Meta, class _Dom> class _RefFunClos; } using __detail::_UnClos; using __detail::_BinClos; using __detail::_SClos; using __detail::_GClos; using __detail::_IClos; using __detail::_ValFunClos; using __detail::_RefFunClos; template class valarray; class slice; template class slice_array; class gslice; template class gslice_array; template class mask_array; template class indirect_array; } # 1 "/usr/include/c++/10/bits/valarray_array.h" 1 3 # 35 "/usr/include/c++/10/bits/valarray_array.h" 3 # 36 "/usr/include/c++/10/bits/valarray_array.h" 3 # 1 "/usr/include/c++/10/cstdlib" 1 3 # 39 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/bits/valarray_array.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template _Tp* __valarray_get_storage(size_t) __attribute__((__malloc__)); template inline _Tp* __valarray_get_storage(size_t __n) { return static_cast<_Tp*>(operator new(__n * sizeof(_Tp))); } inline void __valarray_release_memory(void* __p) { operator delete(__p); } template struct _Array_default_ctor { inline static void _S_do_it(_Tp* __b, _Tp* __e) { while (__b != __e) new(__b++) _Tp(); } }; template struct _Array_default_ctor<_Tp, true> { inline static void _S_do_it(_Tp* __b, _Tp* __e) { __builtin_memset(__b, 0, (__e - __b) * sizeof(_Tp)); } }; template inline void __valarray_default_construct(_Tp* __b, _Tp* __e) { _Array_default_ctor<_Tp, __is_scalar<_Tp>::__value>::_S_do_it(__b, __e); } template struct _Array_init_ctor { inline static void _S_do_it(_Tp* __b, _Tp* __e, const _Tp __t) { while (__b != __e) new(__b++) _Tp(__t); } }; template struct _Array_init_ctor<_Tp, true> { inline static void _S_do_it(_Tp* __b, _Tp* __e, const _Tp __t) { while (__b != __e) *__b++ = __t; } }; template inline void __valarray_fill_construct(_Tp* __b, _Tp* __e, const _Tp __t) { _Array_init_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __t); } template struct _Array_copy_ctor { inline static void _S_do_it(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o) { while (__b != __e) new(__o++) _Tp(*__b++); } }; template struct _Array_copy_ctor<_Tp, true> { inline static void _S_do_it(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o) { if (__b) __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp)); } }; template inline void __valarray_copy_construct(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o) { _Array_copy_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __o); } template inline void __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n, size_t __s, _Tp* __restrict__ __o) { if (__is_trivial(_Tp)) while (__n--) { *__o++ = *__a; __a += __s; } else while (__n--) { new(__o++) _Tp(*__a); __a += __s; } } template inline void __valarray_copy_construct (const _Tp* __restrict__ __a, const size_t* __restrict__ __i, _Tp* __restrict__ __o, size_t __n) { if (__is_trivial(_Tp)) while (__n--) *__o++ = __a[*__i++]; else while (__n--) new (__o++) _Tp(__a[*__i++]); } template inline void __valarray_destroy_elements(_Tp* __b, _Tp* __e) { if (!__is_trivial(_Tp)) while (__b != __e) { __b->~_Tp(); ++__b; } } template inline void __valarray_fill(_Tp* __restrict__ __a, size_t __n, const _Tp& __t) { while (__n--) *__a++ = __t; } template inline void __valarray_fill(_Tp* __restrict__ __a, size_t __n, size_t __s, const _Tp& __t) { for (size_t __i = 0; __i < __n; ++__i, __a += __s) *__a = __t; } template inline void __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i, size_t __n, const _Tp& __t) { for (size_t __j = 0; __j < __n; ++__j, ++__i) __a[*__i] = __t; } template struct _Array_copier { inline static void _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) { while(__n--) *__b++ = *__a++; } }; template struct _Array_copier<_Tp, true> { inline static void _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) { if (__n != 0) __builtin_memcpy(__b, __a, __n * sizeof (_Tp)); } }; template inline void __valarray_copy(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) { _Array_copier<_Tp, __is_trivial(_Tp)>::_S_do_it(__a, __n, __b); } template inline void __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s, _Tp* __restrict__ __b) { for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s) *__b = *__a; } template inline void __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b, size_t __n, size_t __s) { for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s) *__b = *__a; } template inline void __valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1, _Tp* __restrict__ __dst, size_t __s2) { for (size_t __i = 0; __i < __n; ++__i) __dst[__i * __s2] = __src[__i * __s1]; } template inline void __valarray_copy(const _Tp* __restrict__ __a, const size_t* __restrict__ __i, _Tp* __restrict__ __b, size_t __n) { for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i) *__b = __a[*__i]; } template inline void __valarray_copy(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b, const size_t* __restrict__ __i) { for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i) __b[*__i] = *__a; } template inline void __valarray_copy(const _Tp* __restrict__ __src, size_t __n, const size_t* __restrict__ __i, _Tp* __restrict__ __dst, const size_t* __restrict__ __j) { for (size_t __k = 0; __k < __n; ++__k) __dst[*__j++] = __src[*__i++]; } template inline _Tp __valarray_sum(const _Tp* __f, const _Tp* __l) { _Tp __r = *__f++; while (__f != __l) __r += *__f++; return __r; } template inline typename _Ta::value_type __valarray_min(const _Ta& __a) { size_t __s = __a.size(); typedef typename _Ta::value_type _Value_type; _Value_type __r = __s == 0 ? _Value_type() : __a[0]; for (size_t __i = 1; __i < __s; ++__i) { _Value_type __t = __a[__i]; if (__t < __r) __r = __t; } return __r; } template inline typename _Ta::value_type __valarray_max(const _Ta& __a) { size_t __s = __a.size(); typedef typename _Ta::value_type _Value_type; _Value_type __r = __s == 0 ? _Value_type() : __a[0]; for (size_t __i = 1; __i < __s; ++__i) { _Value_type __t = __a[__i]; if (__t > __r) __r = __t; } return __r; } template struct _Array { explicit _Array(_Tp* const __restrict__); explicit _Array(const valarray<_Tp>&); _Array(const _Tp* __restrict__, size_t); _Tp* begin() const; _Tp* const __restrict__ _M_data; }; template inline void __valarray_copy_construct(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { std::__valarray_copy_construct(__a._M_data, __i._M_data, __b._M_data, __n); } template inline void __valarray_copy_construct(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { std::__valarray_copy_construct(__a._M_data, __n, __s, __b._M_data); } template inline void __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t) { std::__valarray_fill(__a._M_data, __n, __t); } template inline void __valarray_fill(_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t) { std::__valarray_fill(__a._M_data, __n, __s, __t); } template inline void __valarray_fill(_Array<_Tp> __a, _Array __i, size_t __n, const _Tp& __t) { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); } template inline void __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { std::__valarray_copy(__a._M_data, __n, __b._M_data); } template inline void __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); } template inline void __valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { __valarray_copy(__a._M_data, __b._M_data, __n, __s); } template inline void __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1, _Array<_Tp> __b, size_t __s2) { std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); } template inline void __valarray_copy(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); } template inline void __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); } template inline void __valarray_copy(_Array<_Tp> __src, size_t __n, _Array __i, _Array<_Tp> __dst, _Array __j) { std::__valarray_copy(__src._M_data, __n, __i._M_data, __dst._M_data, __j._M_data); } template inline _Array<_Tp>::_Array(_Tp* const __restrict__ __p) : _M_data (__p) {} template inline _Array<_Tp>::_Array(const valarray<_Tp>& __v) : _M_data (__v._M_data) {} template inline _Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s) : _M_data(__valarray_get_storage<_Tp>(__s)) { std::__valarray_copy_construct(__b, __s, _M_data); } template inline _Tp* _Array<_Tp>::begin () const { return _M_data; } # 659 "/usr/include/c++/10/bits/valarray_array.h" 3 template inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p += __t; } template inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p += *__q; } template void _Array_augmented___plus(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p += __e[__i]; } template inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p += *__q; } template inline void _Array_augmented___plus(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p += *__q; } template void _Array_augmented___plus(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p += __e[__i]; } template inline void _Array_augmented___plus(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] += *__q; } template inline void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p += __b._M_data[*__j]; } template void _Array_augmented___plus(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] += __e[__k]; } template void _Array_augmented___plus(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p += *__q; } } template void _Array_augmented___plus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p += *__q; } } template void _Array_augmented___plus(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p += __e[__i]; } } template inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p -= __t; } template inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p -= *__q; } template void _Array_augmented___minus(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p -= __e[__i]; } template inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p -= *__q; } template inline void _Array_augmented___minus(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p -= *__q; } template void _Array_augmented___minus(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p -= __e[__i]; } template inline void _Array_augmented___minus(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] -= *__q; } template inline void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p -= __b._M_data[*__j]; } template void _Array_augmented___minus(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] -= __e[__k]; } template void _Array_augmented___minus(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p -= *__q; } } template void _Array_augmented___minus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p -= *__q; } } template void _Array_augmented___minus(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p -= __e[__i]; } } template inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p *= __t; } template inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p *= *__q; } template void _Array_augmented___multiplies(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p *= __e[__i]; } template inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p *= *__q; } template inline void _Array_augmented___multiplies(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p *= *__q; } template void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p *= __e[__i]; } template inline void _Array_augmented___multiplies(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] *= *__q; } template inline void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p *= __b._M_data[*__j]; } template void _Array_augmented___multiplies(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] *= __e[__k]; } template void _Array_augmented___multiplies(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p *= *__q; } } template void _Array_augmented___multiplies(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p *= *__q; } } template void _Array_augmented___multiplies(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p *= __e[__i]; } } template inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p /= __t; } template inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p /= *__q; } template void _Array_augmented___divides(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p /= __e[__i]; } template inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p /= *__q; } template inline void _Array_augmented___divides(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p /= *__q; } template void _Array_augmented___divides(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p /= __e[__i]; } template inline void _Array_augmented___divides(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] /= *__q; } template inline void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p /= __b._M_data[*__j]; } template void _Array_augmented___divides(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] /= __e[__k]; } template void _Array_augmented___divides(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p /= *__q; } } template void _Array_augmented___divides(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p /= *__q; } } template void _Array_augmented___divides(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p /= __e[__i]; } } template inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p %= __t; } template inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p %= *__q; } template void _Array_augmented___modulus(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p %= __e[__i]; } template inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p %= *__q; } template inline void _Array_augmented___modulus(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p %= *__q; } template void _Array_augmented___modulus(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p %= __e[__i]; } template inline void _Array_augmented___modulus(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] %= *__q; } template inline void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p %= __b._M_data[*__j]; } template void _Array_augmented___modulus(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] %= __e[__k]; } template void _Array_augmented___modulus(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p %= *__q; } } template void _Array_augmented___modulus(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p %= *__q; } } template void _Array_augmented___modulus(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p %= __e[__i]; } } template inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p ^= __t; } template inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p ^= *__q; } template void _Array_augmented___bitwise_xor(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p ^= __e[__i]; } template inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p ^= *__q; } template inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p ^= *__q; } template void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p ^= __e[__i]; } template inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] ^= *__q; } template inline void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p ^= __b._M_data[*__j]; } template void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] ^= __e[__k]; } template void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p ^= *__q; } } template void _Array_augmented___bitwise_xor(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p ^= *__q; } } template void _Array_augmented___bitwise_xor(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p ^= __e[__i]; } } template inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p |= __t; } template inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p |= *__q; } template void _Array_augmented___bitwise_or(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p |= __e[__i]; } template inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p |= *__q; } template inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p |= *__q; } template void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p |= __e[__i]; } template inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] |= *__q; } template inline void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p |= __b._M_data[*__j]; } template void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] |= __e[__k]; } template void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p |= *__q; } } template void _Array_augmented___bitwise_or(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p |= *__q; } } template void _Array_augmented___bitwise_or(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p |= __e[__i]; } } template inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p &= __t; } template inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p &= *__q; } template void _Array_augmented___bitwise_and(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p &= __e[__i]; } template inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p &= *__q; } template inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p &= *__q; } template void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p &= __e[__i]; } template inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] &= *__q; } template inline void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p &= __b._M_data[*__j]; } template void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] &= __e[__k]; } template void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p &= *__q; } } template void _Array_augmented___bitwise_and(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p &= *__q; } } template void _Array_augmented___bitwise_and(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p &= __e[__i]; } } template inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p <<= __t; } template inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p <<= *__q; } template void _Array_augmented___shift_left(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p <<= __e[__i]; } template inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p <<= *__q; } template inline void _Array_augmented___shift_left(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p <<= *__q; } template void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p <<= __e[__i]; } template inline void _Array_augmented___shift_left(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] <<= *__q; } template inline void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p <<= __b._M_data[*__j]; } template void _Array_augmented___shift_left(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] <<= __e[__k]; } template void _Array_augmented___shift_left(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p <<= *__q; } } template void _Array_augmented___shift_left(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p <<= *__q; } } template void _Array_augmented___shift_left(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p <<= __e[__i]; } } template inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, const _Tp& __t) { for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) *__p >>= __t; } template inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) { _Tp* __p = __a._M_data; for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) *__p >>= *__q; } template void _Array_augmented___shift_right(_Array<_Tp> __a, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p >>= __e[__i]; } template inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; __p += __s, ++__q) *__p >>= *__q; } template inline void _Array_augmented___shift_right(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) { _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, __q += __s) *__p >>= *__q; } template void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __s, const _Expr<_Dom, _Tp>& __e, size_t __n) { _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p >>= __e[__i]; } template inline void _Array_augmented___shift_right(_Array<_Tp> __a, _Array __i, _Array<_Tp> __b, size_t __n) { _Tp* __q(__b._M_data); for (size_t* __j = __i._M_data; __j < __i._M_data + __n; ++__j, ++__q) __a._M_data[*__j] >>= *__q; } template inline void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __i) { _Tp* __p(__a._M_data); for (size_t* __j = __i._M_data; __j<__i._M_data + __n; ++__j, ++__p) *__p >>= __b._M_data[*__j]; } template void _Array_augmented___shift_right(_Array<_Tp> __a, _Array __i, const _Expr<_Dom, _Tp>& __e, size_t __n) { size_t* __j(__i._M_data); for (size_t __k = 0; __k<__n; ++__k, ++__j) __a._M_data[*__j] >>= __e[__k]; } template void _Array_augmented___shift_right(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p >>= *__q; } } template void _Array_augmented___shift_right(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { bool* __ok(__m._M_data); _Tp* __q(__b._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__p >>= *__q; } } template void _Array_augmented___shift_right(_Array<_Tp> __a, _Array __m, const _Expr<_Dom, _Tp>& __e, size_t __n) { bool* __ok(__m._M_data); _Tp* __p(__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p >>= __e[__i]; } } } # 1 "/usr/include/c++/10/bits/valarray_array.tcc" 1 3 # 35 "/usr/include/c++/10/bits/valarray_array.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template void __valarray_fill(_Array<_Tp> __a, size_t __n, _Array __m, const _Tp& __t) { _Tp* __p = __a._M_data; bool* __ok (__m._M_data); for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p) { while (!*__ok) { ++__ok; ++__p; } *__p = __t; } } template void __valarray_copy(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { _Tp* __p (__a._M_data); bool* __ok (__m._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__q = *__p; } } template void __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array __m) { _Tp* __q (__b._M_data); bool* __ok (__m._M_data); for (_Tp* __p = __a._M_data; __p < __a._M_data+__n; ++__p, ++__ok, ++__q) { while (! *__ok) { ++__ok; ++__q; } *__q = *__p; } } template void __valarray_copy(_Array<_Tp> __a, _Array __m, size_t __n, _Array<_Tp> __b, _Array __k) { _Tp* __p (__a._M_data); _Tp* __q (__b._M_data); bool* __srcok (__m._M_data); bool* __dstok (__k._M_data); for (size_t __i = 0; __i < __n; ++__srcok, ++__p, ++__dstok, ++__q, ++__i) { while (! *__srcok) { ++__srcok; ++__p; } while (! *__dstok) { ++__dstok; ++__q; } *__q = *__p; } } template void __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a) { _Tp* __p (__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) *__p = __e[__i]; } template void __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a, size_t __s) { _Tp* __p (__a._M_data); for (size_t __i = 0; __i < __n; ++__i, __p += __s) *__p = __e[__i]; } template void __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a, _Array __i) { size_t* __j (__i._M_data); for (size_t __k = 0; __k < __n; ++__k, ++__j) __a._M_data[*__j] = __e[__k]; } template void __valarray_copy(_Array<_Tp> __e, _Array __f, size_t __n, _Array<_Tp> __a, _Array __i) { size_t* __g (__f._M_data); size_t* __j (__i._M_data); for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g) __a._M_data[*__j] = __e._M_data[*__g]; } template void __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a, _Array __m) { bool* __ok (__m._M_data); _Tp* __p (__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } *__p = __e[__i]; } } template void __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a) { _Tp* __p (__a._M_data); for (size_t __i = 0; __i < __n; ++__i, ++__p) new (__p) _Tp(__e[__i]); } template void __valarray_copy_construct(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, size_t __n) { _Tp* __p (__a._M_data); bool* __ok (__m._M_data); for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p) { while (! *__ok) { ++__ok; ++__p; } new (__q) _Tp(*__p); } } } # 676 "/usr/include/c++/10/bits/valarray_array.h" 2 3 # 101 "/usr/include/c++/10/valarray" 2 3 # 1 "/usr/include/c++/10/bits/valarray_before.h" 1 3 # 35 "/usr/include/c++/10/bits/valarray_before.h" 3 # 36 "/usr/include/c++/10/bits/valarray_before.h" 3 # 1 "/usr/include/c++/10/bits/slice_array.h" 1 3 # 35 "/usr/include/c++/10/bits/slice_array.h" 3 # 36 "/usr/include/c++/10/bits/slice_array.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 59 "/usr/include/c++/10/bits/slice_array.h" 3 class slice { public: slice(); # 72 "/usr/include/c++/10/bits/slice_array.h" 3 slice(size_t __o, size_t __d, size_t __s); size_t start() const; size_t size() const; size_t stride() const; friend bool operator==(const slice&, const slice&) = default; private: size_t _M_off; size_t _M_sz; size_t _M_st; }; inline slice::slice() : _M_off(0), _M_sz(0), _M_st(0) {} inline slice::slice(size_t __o, size_t __d, size_t __s) : _M_off(__o), _M_sz(__d), _M_st(__s) {} inline size_t slice::start() const { return _M_off; } inline size_t slice::size() const { return _M_sz; } inline size_t slice::stride() const { return _M_st; } # 127 "/usr/include/c++/10/bits/slice_array.h" 3 template class slice_array { public: typedef _Tp value_type; slice_array(const slice_array&); slice_array& operator=(const slice_array&); void operator=(const valarray<_Tp>&) const; void operator*=(const valarray<_Tp>&) const; void operator/=(const valarray<_Tp>&) const; void operator%=(const valarray<_Tp>&) const; void operator+=(const valarray<_Tp>&) const; void operator-=(const valarray<_Tp>&) const; void operator^=(const valarray<_Tp>&) const; void operator&=(const valarray<_Tp>&) const; void operator|=(const valarray<_Tp>&) const; void operator<<=(const valarray<_Tp>&) const; void operator>>=(const valarray<_Tp>&) const; void operator=(const _Tp &) const; template void operator=(const _Expr<_Dom, _Tp>&) const; template void operator*=(const _Expr<_Dom, _Tp>&) const; template void operator/=(const _Expr<_Dom, _Tp>&) const; template void operator%=(const _Expr<_Dom, _Tp>&) const; template void operator+=(const _Expr<_Dom, _Tp>&) const; template void operator-=(const _Expr<_Dom, _Tp>&) const; template void operator^=(const _Expr<_Dom, _Tp>&) const; template void operator&=(const _Expr<_Dom, _Tp>&) const; template void operator|=(const _Expr<_Dom, _Tp>&) const; template void operator<<=(const _Expr<_Dom, _Tp>&) const; template void operator>>=(const _Expr<_Dom, _Tp>&) const; private: friend class valarray<_Tp>; slice_array(_Array<_Tp>, const slice&); const size_t _M_sz; const size_t _M_stride; const _Array<_Tp> _M_array; public: slice_array() = delete; }; template inline slice_array<_Tp>::slice_array(_Array<_Tp> __a, const slice& __s) : _M_sz(__s.size()), _M_stride(__s.stride()), _M_array(__a.begin() + __s.start()) {} template inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& __a) : _M_sz(__a._M_sz), _M_stride(__a._M_stride), _M_array(__a._M_array) {} template inline slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array<_Tp>& __a) { std::__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride, _M_array, _M_stride); return *this; } template inline void slice_array<_Tp>::operator=(const _Tp& __t) const { std::__valarray_fill(_M_array, _M_sz, _M_stride, __t); } template inline void slice_array<_Tp>::operator=(const valarray<_Tp>& __v) const { std::__valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); } template template inline void slice_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const { std::__valarray_copy(__e, _M_sz, _M_array, _M_stride); } # 266 "/usr/include/c++/10/bits/slice_array.h" 3 template inline void slice_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator *=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___multiplies(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator /=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___divides(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator %=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___modulus(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator +=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___plus(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator -=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___minus(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator ^=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator &=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator |=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator <<=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_left(_M_array, _M_stride, __e, _M_sz); } template inline void slice_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v)); } template template inline void slice_array<_Tp>::operator >>=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_right(_M_array, _M_stride, __e, _M_sz); } } # 38 "/usr/include/c++/10/bits/valarray_before.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 53 "/usr/include/c++/10/bits/valarray_before.h" 3 template class _Constant; # 63 "/usr/include/c++/10/bits/valarray_before.h" 3 struct _Abs { template _Tp operator()(const _Tp& __t) const { return abs(__t); } }; struct _Cos { template _Tp operator()(const _Tp& __t) const { return cos(__t); } }; struct _Acos { template _Tp operator()(const _Tp& __t) const { return acos(__t); } }; struct _Cosh { template _Tp operator()(const _Tp& __t) const { return cosh(__t); } }; struct _Sin { template _Tp operator()(const _Tp& __t) const { return sin(__t); } }; struct _Asin { template _Tp operator()(const _Tp& __t) const { return asin(__t); } }; struct _Sinh { template _Tp operator()(const _Tp& __t) const { return sinh(__t); } }; struct _Tan { template _Tp operator()(const _Tp& __t) const { return tan(__t); } }; struct _Atan { template _Tp operator()(const _Tp& __t) const { return atan(__t); } }; struct _Tanh { template _Tp operator()(const _Tp& __t) const { return tanh(__t); } }; struct _Exp { template _Tp operator()(const _Tp& __t) const { return exp(__t); } }; struct _Log { template _Tp operator()(const _Tp& __t) const { return log(__t); } }; struct _Log10 { template _Tp operator()(const _Tp& __t) const { return log10(__t); } }; struct _Sqrt { template _Tp operator()(const _Tp& __t) const { return sqrt(__t); } }; struct __unary_plus { template _Tp operator()(const _Tp& __t) const { return +__t; } }; struct __negate { template _Tp operator()(const _Tp& __t) const { return -__t; } }; struct __bitwise_not { template _Tp operator()(const _Tp& __t) const { return ~__t; } }; struct __plus { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; } }; struct __minus { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; } }; struct __multiplies { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; } }; struct __divides { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; } }; struct __modulus { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; } }; struct __bitwise_xor { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x ^ __y; } }; struct __bitwise_and { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x & __y; } }; struct __bitwise_or { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x | __y; } }; struct __shift_left { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x << __y; } }; struct __shift_right { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x >> __y; } }; struct __logical_and { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; } }; struct __logical_or { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; } }; struct __logical_not { template bool operator()(const _Tp& __x) const { return !__x; } }; struct __equal_to { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; } }; struct __not_equal_to { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; } }; struct __less { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; } }; struct __greater { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; } }; struct __less_equal { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; } }; struct __greater_equal { template bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; } }; struct _Atan2 { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return atan2(__x, __y); } }; struct _Pow { template _Tp operator()(const _Tp& __x, const _Tp& __y) const { return pow(__x, __y); } }; template struct __fun_with_valarray { typedef _Tp result_type; }; template struct __fun_with_valarray<_Tp, false> { }; template struct __fun : __fun_with_valarray<_Tp> { }; template struct __fun<__logical_not, _Tp> { typedef bool result_type; }; template struct __fun<__logical_and, _Tp> { typedef bool result_type; }; template struct __fun<__logical_or, _Tp> { typedef bool result_type; }; template struct __fun<__less, _Tp> { typedef bool result_type; }; template struct __fun<__greater, _Tp> { typedef bool result_type; }; template struct __fun<__less_equal, _Tp> { typedef bool result_type; }; template struct __fun<__greater_equal, _Tp> { typedef bool result_type; }; template struct __fun<__equal_to, _Tp> { typedef bool result_type; }; template struct __fun<__not_equal_to, _Tp> { typedef bool result_type; }; namespace __detail { template struct _ValArrayRef { typedef const _Tp __type; }; template struct _ValArrayRef< valarray<_Tp> > { typedef const valarray<_Tp>& __type; }; template class _FunBase { public: typedef typename _Dom::value_type value_type; _FunBase(const _Dom& __e, value_type __f(_Arg)) : _M_expr(__e), _M_func(__f) {} value_type operator[](size_t __i) const { return _M_func (_M_expr[__i]); } size_t size() const { return _M_expr.size ();} private: typename _ValArrayRef<_Dom>::__type _M_expr; value_type (*_M_func)(_Arg); }; template struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type> { typedef _FunBase<_Dom, typename _Dom::value_type> _Base; typedef typename _Base::value_type value_type; typedef value_type _Tp; _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {} }; template struct _ValFunClos<_ValArray,_Tp> : _FunBase, _Tp> { typedef _FunBase, _Tp> _Base; typedef _Tp value_type; _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {} }; template struct _RefFunClos<_Expr, _Dom> : _FunBase<_Dom, const typename _Dom::value_type&> { typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base; typedef typename _Base::value_type value_type; typedef value_type _Tp; _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&)) : _Base(__e, __f) {} }; template struct _RefFunClos<_ValArray, _Tp> : _FunBase, const _Tp&> { typedef _FunBase, const _Tp&> _Base; typedef _Tp value_type; _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&)) : _Base(__v, __f) {} }; template class _UnBase { public: typedef typename _Arg::value_type _Vt; typedef typename __fun<_Oper, _Vt>::result_type value_type; _UnBase(const _Arg& __e) : _M_expr(__e) {} value_type operator[](size_t __i) const { return _Oper()(_M_expr[__i]); } size_t size() const { return _M_expr.size(); } private: typename _ValArrayRef<_Arg>::__type _M_expr; }; template struct _UnClos<_Oper, _Expr, _Dom> : _UnBase<_Oper, _Dom> { typedef _Dom _Arg; typedef _UnBase<_Oper, _Dom> _Base; typedef typename _Base::value_type value_type; _UnClos(const _Arg& __e) : _Base(__e) {} }; template struct _UnClos<_Oper, _ValArray, _Tp> : _UnBase<_Oper, valarray<_Tp> > { typedef valarray<_Tp> _Arg; typedef _UnBase<_Oper, valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; _UnClos(const _Arg& __e) : _Base(__e) {} }; template class _BinBase { public: typedef typename _FirstArg::value_type _Vt; typedef typename __fun<_Oper, _Vt>::result_type value_type; _BinBase(const _FirstArg& __e1, const _SecondArg& __e2) : _M_expr1(__e1), _M_expr2(__e2) {} value_type operator[](size_t __i) const { return _Oper()(_M_expr1[__i], _M_expr2[__i]); } size_t size() const { return _M_expr1.size(); } private: typename _ValArrayRef<_FirstArg>::__type _M_expr1; typename _ValArrayRef<_SecondArg>::__type _M_expr2; }; template class _BinBase2 { public: typedef typename _Clos::value_type _Vt; typedef typename __fun<_Oper, _Vt>::result_type value_type; _BinBase2(const _Clos& __e, const _Vt& __t) : _M_expr1(__e), _M_expr2(__t) {} value_type operator[](size_t __i) const { return _Oper()(_M_expr1[__i], _M_expr2); } size_t size() const { return _M_expr1.size(); } private: typename _ValArrayRef<_Clos>::__type _M_expr1; _Vt _M_expr2; }; template class _BinBase1 { public: typedef typename _Clos::value_type _Vt; typedef typename __fun<_Oper, _Vt>::result_type value_type; _BinBase1(const _Vt& __t, const _Clos& __e) : _M_expr1(__t), _M_expr2(__e) {} value_type operator[](size_t __i) const { return _Oper()(_M_expr1, _M_expr2[__i]); } size_t size() const { return _M_expr2.size(); } private: _Vt _M_expr1; typename _ValArrayRef<_Clos>::__type _M_expr2; }; template struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2> : _BinBase<_Oper, _Dom1, _Dom2> { typedef _BinBase<_Oper, _Dom1, _Dom2> _Base; typedef typename _Base::value_type value_type; _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {} }; template struct _BinClos<_Oper, _ValArray, _ValArray, _Tp, _Tp> : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > { typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w) : _Base(__v, __w) {} }; template struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type> : _BinBase<_Oper, _Dom, valarray > { typedef typename _Dom::value_type _Tp; typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2) : _Base(__e1, __e2) {} }; template struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom> : _BinBase<_Oper, valarray,_Dom> { typedef typename _Dom::value_type _Tp; typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base; typedef typename _Base::value_type value_type; _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2) : _Base(__e1, __e2) {} }; template struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type> : _BinBase2<_Oper, _Dom> { typedef typename _Dom::value_type _Tp; typedef _BinBase2<_Oper,_Dom> _Base; typedef typename _Base::value_type value_type; _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {} }; template struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom> : _BinBase1<_Oper, _Dom> { typedef typename _Dom::value_type _Tp; typedef _BinBase1<_Oper, _Dom> _Base; typedef typename _Base::value_type value_type; _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {} }; template struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp> : _BinBase2<_Oper, valarray<_Tp> > { typedef _BinBase2<_Oper,valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {} }; template struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp> : _BinBase1<_Oper, valarray<_Tp> > { typedef _BinBase1<_Oper, valarray<_Tp> > _Base; typedef typename _Base::value_type value_type; _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {} }; template class _SBase { public: typedef typename _Dom::value_type value_type; _SBase (const _Dom& __e, const slice& __s) : _M_expr (__e), _M_slice (__s) {} value_type operator[] (size_t __i) const { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; } size_t size() const { return _M_slice.size (); } private: typename _ValArrayRef<_Dom>::__type _M_expr; const slice& _M_slice; }; template class _SBase<_Array<_Tp> > { public: typedef _Tp value_type; _SBase (_Array<_Tp> __a, const slice& __s) : _M_array (__a._M_data+__s.start()), _M_size (__s.size()), _M_stride (__s.stride()) {} value_type operator[] (size_t __i) const { return _M_array._M_data[__i * _M_stride]; } size_t size() const { return _M_size; } private: const _Array<_Tp> _M_array; const size_t _M_size; const size_t _M_stride; }; template struct _SClos<_Expr, _Dom> : _SBase<_Dom> { typedef _SBase<_Dom> _Base; typedef typename _Base::value_type value_type; _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {} }; template struct _SClos<_ValArray, _Tp> : _SBase<_Array<_Tp> > { typedef _SBase<_Array<_Tp> > _Base; typedef _Tp value_type; _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {} }; } } # 102 "/usr/include/c++/10/valarray" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 126 "/usr/include/c++/10/valarray" 3 template class valarray { template struct _UnaryOp { typedef typename __fun<_Op, _Tp>::result_type __rt; typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt; }; public: typedef _Tp value_type; valarray(); explicit valarray(size_t); valarray(const _Tp&, size_t); valarray(const _Tp* __restrict__, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<_Tp>&); valarray(const gslice_array<_Tp>&); valarray(const mask_array<_Tp>&); valarray(const indirect_array<_Tp>&); valarray(initializer_list<_Tp>); template valarray(const _Expr<_Dom, _Tp>& __e); ~valarray() noexcept; # 189 "/usr/include/c++/10/valarray" 3 valarray<_Tp>& operator=(const valarray<_Tp>& __v); # 199 "/usr/include/c++/10/valarray" 3 valarray<_Tp>& operator=(valarray<_Tp>&& __v) noexcept; # 209 "/usr/include/c++/10/valarray" 3 valarray<_Tp>& operator=(const _Tp& __t); # 219 "/usr/include/c++/10/valarray" 3 valarray<_Tp>& operator=(const slice_array<_Tp>& __sa); # 229 "/usr/include/c++/10/valarray" 3 valarray<_Tp>& operator=(const gslice_array<_Tp>& __ga); # 239 "/usr/include/c++/10/valarray" 3 valarray<_Tp>& operator=(const mask_array<_Tp>& __ma); # 249 "/usr/include/c++/10/valarray" 3 valarray<_Tp>& operator=(const indirect_array<_Tp>& __ia); # 260 "/usr/include/c++/10/valarray" 3 valarray& operator=(initializer_list<_Tp> __l); template valarray<_Tp>& operator= (const _Expr<_Dom, _Tp>&); # 273 "/usr/include/c++/10/valarray" 3 _Tp& operator[](size_t __i); const _Tp& operator[](size_t) const; # 290 "/usr/include/c++/10/valarray" 3 _Expr<_SClos<_ValArray, _Tp>, _Tp> operator[](slice __s) const; # 302 "/usr/include/c++/10/valarray" 3 slice_array<_Tp> operator[](slice __s); # 313 "/usr/include/c++/10/valarray" 3 _Expr<_GClos<_ValArray, _Tp>, _Tp> operator[](const gslice& __s) const; # 325 "/usr/include/c++/10/valarray" 3 gslice_array<_Tp> operator[](const gslice& __s); # 339 "/usr/include/c++/10/valarray" 3 valarray<_Tp> operator[](const valarray& __m) const; # 353 "/usr/include/c++/10/valarray" 3 mask_array<_Tp> operator[](const valarray& __m); # 366 "/usr/include/c++/10/valarray" 3 _Expr<_IClos<_ValArray, _Tp>, _Tp> operator[](const valarray& __i) const; # 381 "/usr/include/c++/10/valarray" 3 indirect_array<_Tp> operator[](const valarray& __i); typename _UnaryOp<__unary_plus>::_Rt operator+() const; typename _UnaryOp<__negate>::_Rt operator-() const; typename _UnaryOp<__bitwise_not>::_Rt operator~() const; typename _UnaryOp<__logical_not>::_Rt operator!() const; valarray<_Tp>& operator*=(const _Tp&); valarray<_Tp>& operator/=(const _Tp&); valarray<_Tp>& operator%=(const _Tp&); valarray<_Tp>& operator+=(const _Tp&); valarray<_Tp>& operator-=(const _Tp&); valarray<_Tp>& operator^=(const _Tp&); valarray<_Tp>& operator&=(const _Tp&); valarray<_Tp>& operator|=(const _Tp&); valarray<_Tp>& operator<<=(const _Tp&); valarray<_Tp>& operator>>=(const _Tp&); valarray<_Tp>& operator*=(const valarray<_Tp>&); valarray<_Tp>& operator/=(const valarray<_Tp>&); valarray<_Tp>& operator%=(const valarray<_Tp>&); valarray<_Tp>& operator+=(const valarray<_Tp>&); valarray<_Tp>& operator-=(const valarray<_Tp>&); valarray<_Tp>& operator^=(const valarray<_Tp>&); valarray<_Tp>& operator|=(const valarray<_Tp>&); valarray<_Tp>& operator&=(const valarray<_Tp>&); valarray<_Tp>& operator<<=(const valarray<_Tp>&); valarray<_Tp>& operator>>=(const valarray<_Tp>&); template valarray<_Tp>& operator*=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator/=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator%=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator+=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator-=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator^=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator|=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator&=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator<<=(const _Expr<_Dom, _Tp>&); template valarray<_Tp>& operator>>=(const _Expr<_Dom, _Tp>&); void swap(valarray<_Tp>& __v) noexcept; size_t size() const; _Tp sum() const; _Tp min() const; _Tp max() const; # 516 "/usr/include/c++/10/valarray" 3 valarray<_Tp> shift (int __n) const; # 533 "/usr/include/c++/10/valarray" 3 valarray<_Tp> cshift(int __n) const; # 545 "/usr/include/c++/10/valarray" 3 _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(_Tp)) const; # 557 "/usr/include/c++/10/valarray" 3 _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> apply(_Tp func(const _Tp&)) const; # 568 "/usr/include/c++/10/valarray" 3 void resize(size_t __size, _Tp __c = _Tp()); private: size_t _M_size; _Tp* __restrict__ _M_data; friend class _Array<_Tp>; }; template valarray(const _Tp(&)[_Nm], size_t) -> valarray<_Tp>; template inline const _Tp& valarray<_Tp>::operator[](size_t __i) const { ; return _M_data[__i]; } template inline _Tp& valarray<_Tp>::operator[](size_t __i) { ; return _M_data[__i]; } } # 1 "/usr/include/c++/10/bits/valarray_after.h" 1 3 # 35 "/usr/include/c++/10/bits/valarray_after.h" 3 # 36 "/usr/include/c++/10/bits/valarray_after.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template class _GBase { public: typedef typename _Dom::value_type value_type; _GBase (const _Dom& __e, const valarray& __i) : _M_expr (__e), _M_index(__i) {} value_type operator[] (size_t __i) const { return _M_expr[_M_index[__i]]; } size_t size () const { return _M_index.size(); } private: typename _ValArrayRef<_Dom>::__type _M_expr; const valarray& _M_index; }; template class _GBase<_Array<_Tp> > { public: typedef _Tp value_type; _GBase (_Array<_Tp> __a, const valarray& __i) : _M_array (__a), _M_index(__i) {} value_type operator[] (size_t __i) const { return _M_array._M_data[_M_index[__i]]; } size_t size () const { return _M_index.size(); } private: const _Array<_Tp> _M_array; const valarray& _M_index; }; template struct _GClos<_Expr, _Dom> : _GBase<_Dom> { typedef _GBase<_Dom> _Base; typedef typename _Base::value_type value_type; _GClos (const _Dom& __e, const valarray& __i) : _Base (__e, __i) {} }; template struct _GClos<_ValArray, _Tp> : _GBase<_Array<_Tp> > { typedef _GBase<_Array<_Tp> > _Base; typedef typename _Base::value_type value_type; _GClos (_Array<_Tp> __a, const valarray& __i) : _Base (__a, __i) {} }; template class _IBase { public: typedef typename _Dom::value_type value_type; _IBase (const _Dom& __e, const valarray& __i) : _M_expr (__e), _M_index (__i) {} value_type operator[] (size_t __i) const { return _M_expr[_M_index[__i]]; } size_t size() const { return _M_index.size(); } private: typename _ValArrayRef<_Dom>::__type _M_expr; const valarray& _M_index; }; template struct _IClos<_Expr, _Dom> : _IBase<_Dom> { typedef _IBase<_Dom> _Base; typedef typename _Base::value_type value_type; _IClos (const _Dom& __e, const valarray& __i) : _Base (__e, __i) {} }; template struct _IClos<_ValArray, _Tp> : _IBase > { typedef _IBase > _Base; typedef _Tp value_type; _IClos (const valarray<_Tp>& __a, const valarray& __i) : _Base (__a, __i) {} }; } template class _Expr { public: typedef _Tp value_type; _Expr(const _Clos&); const _Clos& operator()() const; value_type operator[](size_t) const; valarray operator[](slice) const; valarray operator[](const gslice&) const; valarray operator[](const valarray&) const; valarray operator[](const valarray&) const; _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type> operator+() const; _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type> operator-() const; _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type> operator~() const; _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool> operator!() const; size_t size() const; value_type sum() const; valarray shift(int) const; valarray cshift(int) const; value_type min() const; value_type max() const; valarray apply(value_type (*)(const value_type&)) const; valarray apply(value_type (*)(value_type)) const; private: const _Clos _M_closure; }; template inline _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} template inline const _Clos& _Expr<_Clos, _Tp>::operator()() const { return _M_closure; } template inline _Tp _Expr<_Clos, _Tp>::operator[](size_t __i) const { return _M_closure[__i]; } template inline valarray<_Tp> _Expr<_Clos, _Tp>::operator[](slice __s) const { valarray<_Tp> __v = valarray<_Tp>(*this)[__s]; return __v; } template inline valarray<_Tp> _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const { valarray<_Tp> __v = valarray<_Tp>(*this)[__gs]; return __v; } template inline valarray<_Tp> _Expr<_Clos, _Tp>::operator[](const valarray& __m) const { valarray<_Tp> __v = valarray<_Tp>(*this)[__m]; return __v; } template inline valarray<_Tp> _Expr<_Clos, _Tp>::operator[](const valarray& __i) const { valarray<_Tp> __v = valarray<_Tp>(*this)[__i]; return __v; } template inline size_t _Expr<_Clos, _Tp>::size() const { return _M_closure.size(); } template inline valarray<_Tp> _Expr<_Clos, _Tp>::shift(int __n) const { valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n); return __v; } template inline valarray<_Tp> _Expr<_Clos, _Tp>::cshift(int __n) const { valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n); return __v; } template inline valarray<_Tp> _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const { valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f); return __v; } template inline valarray<_Tp> _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const { valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f); return __v; } template inline _Tp _Expr<_Clos, _Tp>::sum() const { size_t __n = _M_closure.size(); if (__n == 0) return _Tp(); else { _Tp __s = _M_closure[--__n]; while (__n != 0) __s += _M_closure[--__n]; return __s; } } template inline _Tp _Expr<_Clos, _Tp>::min() const { return __valarray_min(_M_closure); } template inline _Tp _Expr<_Clos, _Tp>::max() const { return __valarray_max(_M_closure); } template inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool> _Expr<_Dom, _Tp>::operator!() const { typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure; return _Expr<_Closure, bool>(_Closure(this->_M_closure)); } # 334 "/usr/include/c++/10/bits/valarray_after.h" 3 template inline _Expr<_UnClos, _Tp> _Expr<_Dom, _Tp>::operator +() const { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); } template inline _Expr<_UnClos, _Tp> _Expr<_Dom, _Tp>::operator -() const { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); } template inline _Expr<_UnClos, _Tp> _Expr<_Dom, _Tp>::operator ~() const { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); } # 405 "/usr/include/c++/10/bits/valarray_after.h" 3 template inline _Expr<_BinClos, typename __fun::result_type> operator +(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator +(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator +(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator +(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator +(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator -(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator -(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator -(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator -(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator -(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator *(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator *(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator *(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator *(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator *(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator /(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator /(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator /(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator /(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator /(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator %(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator %(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator %(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator %(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator %(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ^(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ^(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator ^(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ^(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator ^(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator &(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator &(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator &(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator &(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator &(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator |(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator |(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator |(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator |(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator |(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <<(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <<(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator <<(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <<(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator <<(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >>(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >>(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator >>(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >>(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator >>(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator &&(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator &&(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator &&(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator &&(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator &&(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ||(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ||(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator ||(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ||(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator ||(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ==(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ==(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator ==(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator ==(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator ==(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator !=(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator !=(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator !=(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator !=(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator !=(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator <(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator <(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator >(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator >(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <=(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <=(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator <=(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator <=(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator <=(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >=(const _Expr<_Dom1, typename _Dom1::value_type>& __v, const _Expr<_Dom2, typename _Dom2::value_type>& __w) { typedef typename _Dom1::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __w())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >=(const _Expr<_Dom, typename _Dom::value_type>& __v, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v(), __t)); } template inline _Expr<_BinClos, typename __fun::result_type> operator >=(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__t, __v())); } template inline _Expr<_BinClos, typename __fun::result_type> operator >=(const _Expr<_Dom,typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Arg; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename __fun::result_type> operator >=(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef typename __fun::result_type _Value; typedef _BinClos _Closure; return _Expr<_Closure, _Value>(_Closure(__v, __e ())); } # 445 "/usr/include/c++/10/bits/valarray_after.h" 3 template inline _Expr<_UnClos, typename _Dom::value_type> abs(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> abs(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> cos(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> cos(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> acos(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> acos(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> cosh(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> cosh(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> sin(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> sin(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> asin(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> asin(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> sinh(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> sinh(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> tan(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> tan(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> tanh(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> tanh(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> atan(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> atan(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> exp(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> exp(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> log(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> log(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> log10(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> log10(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } template inline _Expr<_UnClos, typename _Dom::value_type> sqrt(const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e())); } template inline _Expr<_UnClos, _Tp> sqrt(const valarray<_Tp>& __v) { typedef _UnClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v)); } # 548 "/usr/include/c++/10/bits/valarray_after.h" 3 template inline _Expr<_BinClos, typename _Dom1::value_type> atan2(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, const _Expr<_Dom2, typename _Dom2::value_type>& __e2) { typedef typename _Dom1::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); } template inline _Expr<_BinClos, typename _Dom::value_type> atan2(const _Expr<_Dom, typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename _Dom::value_type> atan2(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __e())); } template inline _Expr<_BinClos, typename _Dom::value_type> atan2(const _Expr<_Dom, typename _Dom::value_type>& __e, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); } template inline _Expr<_BinClos, typename _Dom::value_type> atan2(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __e())); } template inline _Expr<_BinClos, _Tp> atan2(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __w)); } template inline _Expr<_BinClos, _Tp> atan2(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __t)); } template inline _Expr<_BinClos, _Tp> atan2(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __v)); } template inline _Expr<_BinClos, typename _Dom1::value_type> pow(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, const _Expr<_Dom2, typename _Dom2::value_type>& __e2) { typedef typename _Dom1::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); } template inline _Expr<_BinClos, typename _Dom::value_type> pow(const _Expr<_Dom, typename _Dom::value_type>& __e, const valarray& __v) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); } template inline _Expr<_BinClos, typename _Dom::value_type> pow(const valarray& __v, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __e())); } template inline _Expr<_BinClos, typename _Dom::value_type> pow(const _Expr<_Dom, typename _Dom::value_type>& __e, const typename _Dom::value_type& __t) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); } template inline _Expr<_BinClos, typename _Dom::value_type> pow(const typename _Dom::value_type& __t, const _Expr<_Dom, typename _Dom::value_type>& __e) { typedef typename _Dom::value_type _Tp; typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __e())); } template inline _Expr<_BinClos, _Tp> pow(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __w)); } template inline _Expr<_BinClos, _Tp> pow(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__v, __t)); } template inline _Expr<_BinClos, _Tp> pow(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos _Closure; return _Expr<_Closure, _Tp>(_Closure(__t, __v)); } } # 604 "/usr/include/c++/10/valarray" 2 3 # 1 "/usr/include/c++/10/bits/gslice.h" 1 3 # 35 "/usr/include/c++/10/bits/gslice.h" 3 # 36 "/usr/include/c++/10/bits/gslice.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 64 "/usr/include/c++/10/bits/gslice.h" 3 class gslice { public: gslice(); # 80 "/usr/include/c++/10/bits/gslice.h" 3 gslice(size_t __o, const valarray& __l, const valarray& __s); gslice(const gslice&); ~gslice(); gslice& operator=(const gslice&); size_t start() const; valarray size() const; valarray stride() const; private: struct _Indexer { size_t _M_count; size_t _M_start; valarray _M_size; valarray _M_stride; valarray _M_index; _Indexer() : _M_count(1), _M_start(0), _M_size(), _M_stride(), _M_index() {} _Indexer(size_t, const valarray&, const valarray&); void _M_increment_use() { ++_M_count; } size_t _M_decrement_use() { return --_M_count; } }; _Indexer* _M_index; template friend class valarray; }; inline size_t gslice::start() const { return _M_index ? _M_index->_M_start : 0; } inline valarray gslice::size() const { return _M_index ? _M_index->_M_size : valarray(); } inline valarray gslice::stride() const { return _M_index ? _M_index->_M_stride : valarray(); } inline gslice::gslice() : _M_index(new gslice::_Indexer()) {} inline gslice::gslice(size_t __o, const valarray& __l, const valarray& __s) : _M_index(new gslice::_Indexer(__o, __l, __s)) {} inline gslice::gslice(const gslice& __g) : _M_index(__g._M_index) { if (_M_index) _M_index->_M_increment_use(); } inline gslice::~gslice() { if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; } inline gslice& gslice::operator=(const gslice& __g) { if (__g._M_index) __g._M_index->_M_increment_use(); if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; _M_index = __g._M_index; return *this; } } # 606 "/usr/include/c++/10/valarray" 2 3 # 1 "/usr/include/c++/10/bits/gslice_array.h" 1 3 # 35 "/usr/include/c++/10/bits/gslice_array.h" 3 # 36 "/usr/include/c++/10/bits/gslice_array.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 59 "/usr/include/c++/10/bits/gslice_array.h" 3 template class gslice_array { public: typedef _Tp value_type; gslice_array(const gslice_array&); gslice_array& operator=(const gslice_array&); void operator=(const valarray<_Tp>&) const; void operator*=(const valarray<_Tp>&) const; void operator/=(const valarray<_Tp>&) const; void operator%=(const valarray<_Tp>&) const; void operator+=(const valarray<_Tp>&) const; void operator-=(const valarray<_Tp>&) const; void operator^=(const valarray<_Tp>&) const; void operator&=(const valarray<_Tp>&) const; void operator|=(const valarray<_Tp>&) const; void operator<<=(const valarray<_Tp>&) const; void operator>>=(const valarray<_Tp>&) const; void operator=(const _Tp&) const; template void operator=(const _Expr<_Dom, _Tp>&) const; template void operator*=(const _Expr<_Dom, _Tp>&) const; template void operator/=(const _Expr<_Dom, _Tp>&) const; template void operator%=(const _Expr<_Dom, _Tp>&) const; template void operator+=(const _Expr<_Dom, _Tp>&) const; template void operator-=(const _Expr<_Dom, _Tp>&) const; template void operator^=(const _Expr<_Dom, _Tp>&) const; template void operator&=(const _Expr<_Dom, _Tp>&) const; template void operator|=(const _Expr<_Dom, _Tp>&) const; template void operator<<=(const _Expr<_Dom, _Tp>&) const; template void operator>>=(const _Expr<_Dom, _Tp>&) const; private: _Array<_Tp> _M_array; const valarray& _M_index; friend class valarray<_Tp>; gslice_array(_Array<_Tp>, const valarray&); public: gslice_array() = delete; }; template inline gslice_array<_Tp>::gslice_array(_Array<_Tp> __a, const valarray& __i) : _M_array(__a), _M_index(__i) {} template inline gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a) : _M_array(__a._M_array), _M_index(__a._M_index) {} template inline gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a) { std::__valarray_copy(_Array<_Tp>(__a._M_array), _Array(__a._M_index), _M_index.size(), _M_array, _Array(_M_index)); return *this; } template inline void gslice_array<_Tp>::operator=(const _Tp& __t) const { std::__valarray_fill(_M_array, _Array(_M_index), _M_index.size(), __t); } template inline void gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _Array(_M_index)); } template template inline void gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const { std::__valarray_copy (__e, _M_index.size(), _M_array, _Array(_M_index)); } # 205 "/usr/include/c++/10/bits/gslice_array.h" 3 template inline void gslice_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator *= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___multiplies(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator /= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___divides(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator %= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___modulus(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator += (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___plus(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator -= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___minus(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator ^= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator &= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator |= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator <<= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_left(_M_array, _Array(_M_index), __e, _M_index.size()); } template inline void gslice_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _Array(_M_index), _Array<_Tp>(__v), __v.size()); } template template inline void gslice_array<_Tp>::operator >>= (const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_right(_M_array, _Array(_M_index), __e, _M_index.size()); } } # 607 "/usr/include/c++/10/valarray" 2 3 # 1 "/usr/include/c++/10/bits/mask_array.h" 1 3 # 35 "/usr/include/c++/10/bits/mask_array.h" 3 # 36 "/usr/include/c++/10/bits/mask_array.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 61 "/usr/include/c++/10/bits/mask_array.h" 3 template class mask_array { public: typedef _Tp value_type; mask_array (const mask_array&); mask_array& operator=(const mask_array&); void operator=(const valarray<_Tp>&) const; void operator*=(const valarray<_Tp>&) const; void operator/=(const valarray<_Tp>&) const; void operator%=(const valarray<_Tp>&) const; void operator+=(const valarray<_Tp>&) const; void operator-=(const valarray<_Tp>&) const; void operator^=(const valarray<_Tp>&) const; void operator&=(const valarray<_Tp>&) const; void operator|=(const valarray<_Tp>&) const; void operator<<=(const valarray<_Tp>&) const; void operator>>=(const valarray<_Tp>&) const; void operator=(const _Tp&) const; template void operator=(const _Expr<_Dom,_Tp>&) const; template void operator*=(const _Expr<_Dom,_Tp>&) const; template void operator/=(const _Expr<_Dom,_Tp>&) const; template void operator%=(const _Expr<_Dom,_Tp>&) const; template void operator+=(const _Expr<_Dom,_Tp>&) const; template void operator-=(const _Expr<_Dom,_Tp>&) const; template void operator^=(const _Expr<_Dom,_Tp>&) const; template void operator&=(const _Expr<_Dom,_Tp>&) const; template void operator|=(const _Expr<_Dom,_Tp>&) const; template void operator<<=(const _Expr<_Dom,_Tp>&) const; template void operator>>=(const _Expr<_Dom,_Tp>&) const; private: mask_array(_Array<_Tp>, size_t, _Array); friend class valarray<_Tp>; const size_t _M_sz; const _Array _M_mask; const _Array<_Tp> _M_array; public: mask_array() = delete; }; template inline mask_array<_Tp>::mask_array(const mask_array<_Tp>& __a) : _M_sz(__a._M_sz), _M_mask(__a._M_mask), _M_array(__a._M_array) {} template inline mask_array<_Tp>::mask_array(_Array<_Tp> __a, size_t __s, _Array __m) : _M_sz(__s), _M_mask(__m), _M_array(__a) {} template inline mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array<_Tp>& __a) { std::__valarray_copy(__a._M_array, __a._M_mask, _M_sz, _M_array, _M_mask); return *this; } template inline void mask_array<_Tp>::operator=(const _Tp& __t) const { std::__valarray_fill(_M_array, _M_sz, _M_mask, __t); } template inline void mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); } template template inline void mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); } # 195 "/usr/include/c++/10/bits/mask_array.h" 3 template inline void mask_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator *=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___multiplies(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator /=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___divides(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator %=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___modulus(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator +=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___plus(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator -=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___minus(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator ^=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator &=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator |=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator <<=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_left(_M_array, _M_mask, __e, __e.size()); } template inline void mask_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _M_mask, _Array<_Tp>(__v), __v.size()); } template template inline void mask_array<_Tp>::operator >>=(const _Expr<_Dom, _Tp>& __e) const { _Array_augmented___shift_right(_M_array, _M_mask, __e, __e.size()); } } # 608 "/usr/include/c++/10/valarray" 2 3 # 1 "/usr/include/c++/10/bits/indirect_array.h" 1 3 # 35 "/usr/include/c++/10/bits/indirect_array.h" 3 # 36 "/usr/include/c++/10/bits/indirect_array.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 61 "/usr/include/c++/10/bits/indirect_array.h" 3 template class indirect_array { public: typedef _Tp value_type; indirect_array(const indirect_array&); indirect_array& operator=(const indirect_array&); void operator=(const valarray<_Tp>&) const; void operator*=(const valarray<_Tp>&) const; void operator/=(const valarray<_Tp>&) const; void operator%=(const valarray<_Tp>&) const; void operator+=(const valarray<_Tp>&) const; void operator-=(const valarray<_Tp>&) const; void operator^=(const valarray<_Tp>&) const; void operator&=(const valarray<_Tp>&) const; void operator|=(const valarray<_Tp>&) const; void operator<<=(const valarray<_Tp>&) const; void operator>>=(const valarray<_Tp>&) const; void operator= (const _Tp&) const; template void operator=(const _Expr<_Dom, _Tp>&) const; template void operator*=(const _Expr<_Dom, _Tp>&) const; template void operator/=(const _Expr<_Dom, _Tp>&) const; template void operator%=(const _Expr<_Dom, _Tp>&) const; template void operator+=(const _Expr<_Dom, _Tp>&) const; template void operator-=(const _Expr<_Dom, _Tp>&) const; template void operator^=(const _Expr<_Dom, _Tp>&) const; template void operator&=(const _Expr<_Dom, _Tp>&) const; template void operator|=(const _Expr<_Dom, _Tp>&) const; template void operator<<=(const _Expr<_Dom, _Tp>&) const; template void operator>>=(const _Expr<_Dom, _Tp>&) const; private: indirect_array(_Array<_Tp>, size_t, _Array); friend class valarray<_Tp>; friend class gslice_array<_Tp>; const size_t _M_sz; const _Array _M_index; const _Array<_Tp> _M_array; indirect_array(); }; template inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a) : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {} template inline indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s, _Array __i) : _M_sz(__s), _M_index(__i), _M_array(__a) {} template inline indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a) { std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, _M_index); return *this; } template inline void indirect_array<_Tp>::operator=(const _Tp& __t) const { std::__valarray_fill(_M_array, _M_index, _M_sz, __t); } template inline void indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const { std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); } template template inline void indirect_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const { std::__valarray_copy(__e, _M_sz, _M_array, _M_index); } # 194 "/usr/include/c++/10/bits/indirect_array.h" 3 template inline void indirect_array<_Tp>::operator *=(const valarray<_Tp>& __v) const { _Array_augmented___multiplies(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator *=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___multiplies(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator /=(const valarray<_Tp>& __v) const { _Array_augmented___divides(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator /=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___divides(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator %=(const valarray<_Tp>& __v) const { _Array_augmented___modulus(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator %=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___modulus(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator +=(const valarray<_Tp>& __v) const { _Array_augmented___plus(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator +=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___plus(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator -=(const valarray<_Tp>& __v) const { _Array_augmented___minus(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator -=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___minus(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator ^=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_xor(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator ^=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_xor(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator &=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_and(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator &=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_and(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator |=(const valarray<_Tp>& __v) const { _Array_augmented___bitwise_or(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator |=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___bitwise_or(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator <<=(const valarray<_Tp>& __v) const { _Array_augmented___shift_left(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator <<=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_left(_M_array, _M_index, __e, _M_sz); } template inline void indirect_array<_Tp>::operator >>=(const valarray<_Tp>& __v) const { _Array_augmented___shift_right(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); } template template inline void indirect_array<_Tp>::operator >>=(const _Expr<_Dom,_Tp>& __e) const { _Array_augmented___shift_right(_M_array, _M_index, __e, _M_sz); } } # 609 "/usr/include/c++/10/valarray" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template inline valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} template inline valarray<_Tp>::valarray(size_t __n) : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) { std::__valarray_default_construct(_M_data, _M_data + __n); } template inline valarray<_Tp>::valarray(const _Tp& __t, size_t __n) : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) { std::__valarray_fill_construct(_M_data, _M_data + __n, __t); } template inline valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) { ; std::__valarray_copy_construct(__p, __p + __n, _M_data); } template inline valarray<_Tp>::valarray(const valarray<_Tp>& __v) : _M_size(__v._M_size), _M_data(__valarray_get_storage<_Tp>(__v._M_size)) { std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); } template inline valarray<_Tp>::valarray(valarray<_Tp>&& __v) noexcept : _M_size(__v._M_size), _M_data(__v._M_data) { __v._M_size = 0; __v._M_data = 0; } template inline valarray<_Tp>::valarray(const slice_array<_Tp>& __sa) : _M_size(__sa._M_sz), _M_data(__valarray_get_storage<_Tp>(__sa._M_sz)) { std::__valarray_copy_construct (__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); } template inline valarray<_Tp>::valarray(const gslice_array<_Tp>& __ga) : _M_size(__ga._M_index.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) { std::__valarray_copy_construct (__ga._M_array, _Array(__ga._M_index), _Array<_Tp>(_M_data), _M_size); } template inline valarray<_Tp>::valarray(const mask_array<_Tp>& __ma) : _M_size(__ma._M_sz), _M_data(__valarray_get_storage<_Tp>(__ma._M_sz)) { std::__valarray_copy_construct (__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); } template inline valarray<_Tp>::valarray(const indirect_array<_Tp>& __ia) : _M_size(__ia._M_sz), _M_data(__valarray_get_storage<_Tp>(__ia._M_sz)) { std::__valarray_copy_construct (__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); } template inline valarray<_Tp>::valarray(initializer_list<_Tp> __l) : _M_size(__l.size()), _M_data(__valarray_get_storage<_Tp>(__l.size())) { std::__valarray_copy_construct(__l.begin(), __l.end(), _M_data); } template template inline valarray<_Tp>::valarray(const _Expr<_Dom, _Tp>& __e) : _M_size(__e.size()), _M_data(__valarray_get_storage<_Tp>(_M_size)) { std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); } template inline valarray<_Tp>::~valarray() noexcept { std::__valarray_destroy_elements(_M_data, _M_data + _M_size); std::__valarray_release_memory(_M_data); } template inline valarray<_Tp>& valarray<_Tp>::operator=(const valarray<_Tp>& __v) { if (_M_size == __v._M_size) std::__valarray_copy(__v._M_data, _M_size, _M_data); else { if (_M_data) { std::__valarray_destroy_elements(_M_data, _M_data + _M_size); std::__valarray_release_memory(_M_data); } _M_size = __v._M_size; _M_data = __valarray_get_storage<_Tp>(_M_size); std::__valarray_copy_construct(__v._M_data, __v._M_data + _M_size, _M_data); } return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(valarray<_Tp>&& __v) noexcept { if (_M_data) { std::__valarray_destroy_elements(_M_data, _M_data + _M_size); std::__valarray_release_memory(_M_data); } _M_size = __v._M_size; _M_data = __v._M_data; __v._M_size = 0; __v._M_data = 0; return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list<_Tp> __l) { if (_M_size == __l.size()) std::__valarray_copy(__l.begin(), __l.size(), _M_data); else { if (_M_data) { std::__valarray_destroy_elements(_M_data, _M_data + _M_size); std::__valarray_release_memory(_M_data); } _M_size = __l.size(); _M_data = __valarray_get_storage<_Tp>(_M_size); std::__valarray_copy_construct(__l.begin(), __l.begin() + _M_size, _M_data); } return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const _Tp& __t) { std::__valarray_fill(_M_data, _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<_Tp>& __sa) { ; std::__valarray_copy(__sa._M_array, __sa._M_sz, __sa._M_stride, _Array<_Tp>(_M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<_Tp>& __ga) { ; std::__valarray_copy(__ga._M_array, _Array(__ga._M_index), _Array<_Tp>(_M_data), _M_size); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<_Tp>& __ma) { ; std::__valarray_copy(__ma._M_array, __ma._M_mask, _Array<_Tp>(_M_data), _M_size); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<_Tp>& __ia) { ; std::__valarray_copy(__ia._M_array, __ia._M_index, _Array<_Tp>(_M_data), _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) { if (_M_size == __e.size()) std::__valarray_copy(__e, _M_size, _Array<_Tp>(_M_data)); else { if (_M_data) { std::__valarray_destroy_elements(_M_data, _M_data + _M_size); std::__valarray_release_memory(_M_data); } _M_size = __e.size(); _M_data = __valarray_get_storage<_Tp>(_M_size); std::__valarray_copy_construct(__e, _M_size, _Array<_Tp>(_M_data)); } return *this; } template inline _Expr<_SClos<_ValArray,_Tp>, _Tp> valarray<_Tp>::operator[](slice __s) const { typedef _SClos<_ValArray,_Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure (_Array<_Tp>(_M_data), __s)); } template inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) { return slice_array<_Tp>(_Array<_Tp>(_M_data), __s); } template inline _Expr<_GClos<_ValArray,_Tp>, _Tp> valarray<_Tp>::operator[](const gslice& __gs) const { typedef _GClos<_ValArray,_Tp> _Closure; return _Expr<_Closure, _Tp> (_Closure(_Array<_Tp>(_M_data), __gs._M_index->_M_index)); } template inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) { return gslice_array<_Tp> (_Array<_Tp>(_M_data), __gs._M_index->_M_index); } template inline valarray<_Tp> valarray<_Tp>::operator[](const valarray& __m) const { size_t __s = 0; size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) if (__m[__i]) ++__s; return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array (__m))); } template inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray& __m) { size_t __s = 0; size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) if (__m[__i]) ++__s; return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array(__m)); } template inline _Expr<_IClos<_ValArray,_Tp>, _Tp> valarray<_Tp>::operator[](const valarray& __i) const { typedef _IClos<_ValArray,_Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(*this, __i)); } template inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray& __i) { return indirect_array<_Tp>(_Array<_Tp>(_M_data), __i.size(), _Array(__i)); } template inline void valarray<_Tp>::swap(valarray<_Tp>& __v) noexcept { std::swap(_M_size, __v._M_size); std::swap(_M_data, __v._M_data); } template inline size_t valarray<_Tp>::size() const { return _M_size; } template inline _Tp valarray<_Tp>::sum() const { ; return std::__valarray_sum(_M_data, _M_data + _M_size); } template inline valarray<_Tp> valarray<_Tp>::shift(int __n) const { valarray<_Tp> __ret; if (_M_size == 0) return __ret; _Tp* __restrict__ __tmp_M_data = std::__valarray_get_storage<_Tp>(_M_size); if (__n == 0) std::__valarray_copy_construct(_M_data, _M_data + _M_size, __tmp_M_data); else if (__n > 0) { if (size_t(__n) > _M_size) __n = int(_M_size); std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size, __tmp_M_data); std::__valarray_default_construct(__tmp_M_data + _M_size - __n, __tmp_M_data + _M_size); } else { if (-size_t(__n) > _M_size) __n = -int(_M_size); std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n, __tmp_M_data - __n); std::__valarray_default_construct(__tmp_M_data, __tmp_M_data - __n); } __ret._M_size = _M_size; __ret._M_data = __tmp_M_data; return __ret; } template inline valarray<_Tp> valarray<_Tp>::cshift(int __n) const { valarray<_Tp> __ret; if (_M_size == 0) return __ret; _Tp* __restrict__ __tmp_M_data = std::__valarray_get_storage<_Tp>(_M_size); if (__n == 0) std::__valarray_copy_construct(_M_data, _M_data + _M_size, __tmp_M_data); else if (__n > 0) { if (size_t(__n) > _M_size) __n = int(__n % _M_size); std::__valarray_copy_construct(_M_data, _M_data + __n, __tmp_M_data + _M_size - __n); std::__valarray_copy_construct(_M_data + __n, _M_data + _M_size, __tmp_M_data); } else { if (-size_t(__n) > _M_size) __n = -int(-size_t(__n) % _M_size); std::__valarray_copy_construct(_M_data + _M_size + __n, _M_data + _M_size, __tmp_M_data); std::__valarray_copy_construct(_M_data, _M_data + _M_size + __n, __tmp_M_data - __n); } __ret._M_size = _M_size; __ret._M_data = __tmp_M_data; return __ret; } template inline void valarray<_Tp>::resize(size_t __n, _Tp __c) { std::__valarray_destroy_elements(_M_data, _M_data + _M_size); if (_M_size != __n) { std::__valarray_release_memory(_M_data); _M_size = __n; _M_data = __valarray_get_storage<_Tp>(__n); } std::__valarray_fill_construct(_M_data, _M_data + __n, __c); } template inline _Tp valarray<_Tp>::min() const { ; return *std::min_element(_M_data, _M_data + _M_size); } template inline _Tp valarray<_Tp>::max() const { ; return *std::max_element(_M_data, _M_data + _M_size); } template inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> valarray<_Tp>::apply(_Tp func(_Tp)) const { typedef _ValFunClos<_ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(*this, func)); } template inline _Expr<_RefFunClos<_ValArray, _Tp>, _Tp> valarray<_Tp>::apply(_Tp func(const _Tp &)) const { typedef _RefFunClos<_ValArray, _Tp> _Closure; return _Expr<_Closure, _Tp>(_Closure(*this, func)); } # 1089 "/usr/include/c++/10/valarray" 3 template inline typename valarray<_Tp>::template _UnaryOp<__unary_plus>::_Rt valarray<_Tp>::operator +() const { typedef _UnClos<__unary_plus, _ValArray, _Tp> _Closure; typedef typename __fun<__unary_plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); } template inline typename valarray<_Tp>::template _UnaryOp<__negate>::_Rt valarray<_Tp>::operator -() const { typedef _UnClos<__negate, _ValArray, _Tp> _Closure; typedef typename __fun<__negate, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); } template inline typename valarray<_Tp>::template _UnaryOp<__bitwise_not>::_Rt valarray<_Tp>::operator ~() const { typedef _UnClos<__bitwise_not, _ValArray, _Tp> _Closure; typedef typename __fun<__bitwise_not, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); } template inline typename valarray<_Tp>::template _UnaryOp<__logical_not>::_Rt valarray<_Tp>::operator !() const { typedef _UnClos<__logical_not, _ValArray, _Tp> _Closure; typedef typename __fun<__logical_not, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(*this)); } # 1115 "/usr/include/c++/10/valarray" 3 template inline valarray<_Tp>& valarray<_Tp>::operator +=(const _Tp &__t) { _Array_augmented___plus(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator +=(const valarray<_Tp> &__v) { ; _Array_augmented___plus(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator -=(const _Tp &__t) { _Array_augmented___minus(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator -=(const valarray<_Tp> &__v) { ; _Array_augmented___minus(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator *=(const _Tp &__t) { _Array_augmented___multiplies(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator *=(const valarray<_Tp> &__v) { ; _Array_augmented___multiplies(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator /=(const _Tp &__t) { _Array_augmented___divides(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator /=(const valarray<_Tp> &__v) { ; _Array_augmented___divides(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator %=(const _Tp &__t) { _Array_augmented___modulus(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator %=(const valarray<_Tp> &__v) { ; _Array_augmented___modulus(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator ^=(const _Tp &__t) { _Array_augmented___bitwise_xor(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator ^=(const valarray<_Tp> &__v) { ; _Array_augmented___bitwise_xor(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator &=(const _Tp &__t) { _Array_augmented___bitwise_and(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator &=(const valarray<_Tp> &__v) { ; _Array_augmented___bitwise_and(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator |=(const _Tp &__t) { _Array_augmented___bitwise_or(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator |=(const valarray<_Tp> &__v) { ; _Array_augmented___bitwise_or(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator <<=(const _Tp &__t) { _Array_augmented___shift_left(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator <<=(const valarray<_Tp> &__v) { ; _Array_augmented___shift_left(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator >>=(const _Tp &__t) { _Array_augmented___shift_right(_Array<_Tp>(_M_data), _M_size, __t); return *this; } template inline valarray<_Tp>& valarray<_Tp>::operator >>=(const valarray<_Tp> &__v) { ; _Array_augmented___shift_right(_Array<_Tp>(_M_data), _M_size, _Array<_Tp>(__v._M_data)); return *this; } # 1137 "/usr/include/c++/10/valarray" 3 template template inline valarray<_Tp>& valarray<_Tp>::operator +=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___plus(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator -=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___minus(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator *=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___multiplies(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator /=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___divides(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator %=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___modulus(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator ^=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___bitwise_xor(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator &=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___bitwise_and(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator |=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___bitwise_or(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator <<=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___shift_left(_Array<_Tp>(_M_data), __e, _M_size); return *this; } template template inline valarray<_Tp>& valarray<_Tp>::operator >>=(const _Expr<_Dom, _Tp>& __e) { _Array_augmented___shift_right(_Array<_Tp>(_M_data), __e, _M_size); return *this; } # 1185 "/usr/include/c++/10/valarray" 3 template inline _Expr<_BinClos<__plus, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__plus, _Tp>::result_type> operator +(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__plus, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__plus, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__plus, _Tp>::result_type> operator +(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__plus, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__plus, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__plus, _Tp>::result_type> operator +(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__plus, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__plus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__minus, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__minus, _Tp>::result_type> operator -(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__minus, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__minus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__minus, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__minus, _Tp>::result_type> operator -(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__minus, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__minus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__minus, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__minus, _Tp>::result_type> operator -(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__minus, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__minus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__multiplies, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__multiplies, _Tp>::result_type> operator *(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__multiplies, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__multiplies, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__multiplies, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__multiplies, _Tp>::result_type> operator *(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__multiplies, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__multiplies, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__multiplies, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__multiplies, _Tp>::result_type> operator *(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__multiplies, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__multiplies, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__divides, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__divides, _Tp>::result_type> operator /(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__divides, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__divides, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__divides, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__divides, _Tp>::result_type> operator /(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__divides, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__divides, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__divides, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__divides, _Tp>::result_type> operator /(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__divides, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__divides, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__modulus, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__modulus, _Tp>::result_type> operator %(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__modulus, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__modulus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__modulus, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__modulus, _Tp>::result_type> operator %(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__modulus, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__modulus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__modulus, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__modulus, _Tp>::result_type> operator %(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__modulus, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__modulus, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__bitwise_xor, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_xor, _Tp>::result_type> operator ^(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__bitwise_xor, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_xor, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__bitwise_xor, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__bitwise_xor, _Tp>::result_type> operator ^(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__bitwise_xor, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_xor, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__bitwise_xor, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_xor, _Tp>::result_type> operator ^(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__bitwise_xor, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_xor, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__bitwise_and, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_and, _Tp>::result_type> operator &(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__bitwise_and, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__bitwise_and, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__bitwise_and, _Tp>::result_type> operator &(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__bitwise_and, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__bitwise_and, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_and, _Tp>::result_type> operator &(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__bitwise_and, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__bitwise_or, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_or, _Tp>::result_type> operator |(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__bitwise_or, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__bitwise_or, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__bitwise_or, _Tp>::result_type> operator |(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__bitwise_or, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__bitwise_or, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__bitwise_or, _Tp>::result_type> operator |(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__bitwise_or, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__bitwise_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__shift_left, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__shift_left, _Tp>::result_type> operator <<(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__shift_left, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_left, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__shift_left, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__shift_left, _Tp>::result_type> operator <<(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__shift_left, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__shift_left, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__shift_left, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__shift_left, _Tp>::result_type> operator <<(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__shift_left, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_left, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__shift_right, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__shift_right, _Tp>::result_type> operator >>(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__shift_right, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_right, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__shift_right, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__shift_right, _Tp>::result_type> operator >>(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__shift_right, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__shift_right, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__shift_right, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__shift_right, _Tp>::result_type> operator >>(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__shift_right, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__shift_right, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__logical_and, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__logical_and, _Tp>::result_type> operator &&(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__logical_and, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__logical_and, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__logical_and, _Tp>::result_type> operator &&(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__logical_and, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__logical_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__logical_and, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__logical_and, _Tp>::result_type> operator &&(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__logical_and, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_and, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__logical_or, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__logical_or, _Tp>::result_type> operator ||(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__logical_or, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__logical_or, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__logical_or, _Tp>::result_type> operator ||(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__logical_or, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__logical_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__logical_or, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__logical_or, _Tp>::result_type> operator ||(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__logical_or, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__logical_or, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__equal_to, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__equal_to, _Tp>::result_type> operator ==(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__equal_to, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__equal_to, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__equal_to, _Tp>::result_type> operator ==(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__equal_to, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__equal_to, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__equal_to, _Tp>::result_type> operator ==(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__equal_to, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__not_equal_to, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__not_equal_to, _Tp>::result_type> operator !=(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__not_equal_to, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__not_equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__not_equal_to, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__not_equal_to, _Tp>::result_type> operator !=(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__not_equal_to, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__not_equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__not_equal_to, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__not_equal_to, _Tp>::result_type> operator !=(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__not_equal_to, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__not_equal_to, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__less, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__less, _Tp>::result_type> operator <(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__less, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__less, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__less, _Tp>::result_type> operator <(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__less, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__less, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__less, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__less, _Tp>::result_type> operator <(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__less, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__greater, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__greater, _Tp>::result_type> operator >(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__greater, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__greater, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__greater, _Tp>::result_type> operator >(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__greater, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__greater, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__greater, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__greater, _Tp>::result_type> operator >(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__greater, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__less_equal, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__less_equal, _Tp>::result_type> operator <=(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__less_equal, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__less_equal, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__less_equal, _Tp>::result_type> operator <=(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__less_equal, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__less_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__less_equal, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__less_equal, _Tp>::result_type> operator <=(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__less_equal, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__less_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } template inline _Expr<_BinClos<__greater_equal, _ValArray, _ValArray, _Tp, _Tp>, typename __fun<__greater_equal, _Tp>::result_type> operator >=(const valarray<_Tp>& __v, const valarray<_Tp>& __w) { ; typedef _BinClos<__greater_equal, _ValArray, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __w)); } template inline _Expr<_BinClos<__greater_equal, _ValArray,_Constant, _Tp, _Tp>, typename __fun<__greater_equal, _Tp>::result_type> operator >=(const valarray<_Tp>& __v, const typename valarray<_Tp>::value_type& __t) { typedef _BinClos<__greater_equal, _ValArray, _Constant, _Tp, _Tp> _Closure; typedef typename __fun<__greater_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__v, __t)); } template inline _Expr<_BinClos<__greater_equal, _Constant, _ValArray, _Tp, _Tp>, typename __fun<__greater_equal, _Tp>::result_type> operator >=(const typename valarray<_Tp>::value_type& __t, const valarray<_Tp>& __v) { typedef _BinClos<__greater_equal, _Constant, _ValArray, _Tp, _Tp> _Closure; typedef typename __fun<__greater_equal, _Tp>::result_type _Rt; return _Expr<_Closure, _Rt>(_Closure(__t, __v)); } # 1212 "/usr/include/c++/10/valarray" 3 template inline _Tp* begin(valarray<_Tp>& __va) { return std::__addressof(__va[0]); } template inline const _Tp* begin(const valarray<_Tp>& __va) { return std::__addressof(__va[0]); } template inline _Tp* end(valarray<_Tp>& __va) { return std::__addressof(__va[0]) + __va.size(); } template inline const _Tp* end(const valarray<_Tp>& __va) { return std::__addressof(__va[0]) + __va.size(); } } # 80 "all-std.cxx" 2 # 1 "/usr/include/c++/10/clocale" 1 3 # 39 "/usr/include/c++/10/clocale" 3 # 40 "/usr/include/c++/10/clocale" 3 # 81 "all-std.cxx" 2 # 1 "/usr/include/c++/10/codecvt" 1 3 # 34 "/usr/include/c++/10/codecvt" 3 # 35 "/usr/include/c++/10/codecvt" 3 # 1 "/usr/include/c++/10/bits/codecvt.h" 1 3 # 39 "/usr/include/c++/10/bits/codecvt.h" 3 # 40 "/usr/include/c++/10/bits/codecvt.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { class codecvt_base { public: enum result { ok, partial, error, noconv }; }; # 67 "/usr/include/c++/10/bits/codecvt.h" 3 template class __codecvt_abstract_base : public locale::facet, public codecvt_base { public: typedef codecvt_base::result result; typedef _InternT intern_type; typedef _ExternT extern_type; typedef _StateT state_type; # 115 "/usr/include/c++/10/bits/codecvt.h" 3 result out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const { return this->do_out(__state, __from, __from_end, __from_next, __to, __to_end, __to_next); } # 154 "/usr/include/c++/10/bits/codecvt.h" 3 result unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const { return this->do_unshift(__state, __to,__to_end,__to_next); } # 195 "/usr/include/c++/10/bits/codecvt.h" 3 result in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const { return this->do_in(__state, __from, __from_end, __from_next, __to, __to_end, __to_next); } int encoding() const throw() { return this->do_encoding(); } bool always_noconv() const throw() { return this->do_always_noconv(); } int length(state_type& __state, const extern_type* __from, const extern_type* __end, size_t __max) const { return this->do_length(__state, __from, __end, __max); } int max_length() const throw() { return this->do_max_length(); } protected: explicit __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { } virtual ~__codecvt_abstract_base() { } # 236 "/usr/include/c++/10/bits/codecvt.h" 3 virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const = 0; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const = 0; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const = 0; virtual int do_encoding() const throw() = 0; virtual bool do_always_noconv() const throw() = 0; virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const = 0; virtual int do_max_length() const throw() = 0; }; # 273 "/usr/include/c++/10/bits/codecvt.h" 3 template class codecvt : public __codecvt_abstract_base<_InternT, _ExternT, _StateT> { public: typedef codecvt_base::result result; typedef _InternT intern_type; typedef _ExternT extern_type; typedef _StateT state_type; protected: __c_locale _M_c_locale_codecvt; public: static locale::id id; explicit codecvt(size_t __refs = 0) : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs), _M_c_locale_codecvt(0) { } explicit codecvt(__c_locale __cloc, size_t __refs = 0); protected: virtual ~codecvt() { } virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const; virtual int do_encoding() const throw(); virtual bool do_always_noconv() const throw(); virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const; virtual int do_max_length() const throw(); }; template locale::id codecvt<_InternT, _ExternT, _StateT>::id; template<> class codecvt : public __codecvt_abstract_base { friend class messages; public: typedef char intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __c_locale _M_c_locale_codecvt; public: static locale::id id; explicit codecvt(size_t __refs = 0); explicit codecvt(__c_locale __cloc, size_t __refs = 0); protected: virtual ~codecvt(); virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const; virtual int do_encoding() const throw(); virtual bool do_always_noconv() const throw(); virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const; virtual int do_max_length() const throw(); }; template<> class codecvt : public __codecvt_abstract_base { friend class messages; public: typedef wchar_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __c_locale _M_c_locale_codecvt; public: static locale::id id; explicit codecvt(size_t __refs = 0); explicit codecvt(__c_locale __cloc, size_t __refs = 0); protected: virtual ~codecvt(); virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const; virtual int do_encoding() const throw(); virtual bool do_always_noconv() const throw(); virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const; virtual int do_max_length() const throw(); }; template<> class codecvt : public __codecvt_abstract_base { 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(__refs) { } protected: virtual ~codecvt(); virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const; virtual int do_encoding() const throw(); virtual bool do_always_noconv() const throw(); virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const; virtual int do_max_length() const throw(); }; template<> class codecvt : public __codecvt_abstract_base { 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(__refs) { } protected: virtual ~codecvt(); virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const; virtual int do_encoding() const throw(); virtual bool do_always_noconv() const throw(); virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const; virtual int do_max_length() const throw(); }; template<> class codecvt : public __codecvt_abstract_base { 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(__refs) { } protected: virtual ~codecvt(); virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const; virtual int do_encoding() const throw(); virtual bool do_always_noconv() const throw(); virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const; virtual int do_max_length() const throw(); }; template<> class codecvt : public __codecvt_abstract_base { 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(__refs) { } protected: virtual ~codecvt(); virtual result do_out(state_type& __state, const intern_type* __from, const intern_type* __from_end, const intern_type*& __from_next, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_unshift(state_type& __state, extern_type* __to, extern_type* __to_end, extern_type*& __to_next) const; virtual result do_in(state_type& __state, const extern_type* __from, const extern_type* __from_end, const extern_type*& __from_next, intern_type* __to, intern_type* __to_end, intern_type*& __to_next) const; virtual int do_encoding() const throw(); virtual bool do_always_noconv() const throw(); virtual int do_length(state_type&, const extern_type* __from, const extern_type* __end, size_t __max) const; virtual int do_max_length() const throw(); }; template class codecvt_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 : public codecvt { public: explicit codecvt_byname(const char*, size_t __refs = 0) : codecvt(__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 : public codecvt { public: explicit codecvt_byname(const char*, size_t __refs = 0) : codecvt(__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 : public codecvt { public: explicit codecvt_byname(const char* __s, size_t __refs = 0) : codecvt(__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 : public codecvt { public: explicit codecvt_byname(const char* __s, size_t __refs = 0) : codecvt(__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; extern template const codecvt& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template class codecvt_byname; extern template const codecvt& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template class codecvt_byname; extern template class codecvt_byname; extern template class codecvt_byname; extern template class codecvt_byname; } # 42 "/usr/include/c++/10/codecvt" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { enum codecvt_mode { consume_header = 4, generate_header = 2, little_endian = 1 }; template class codecvt_utf8 : public codecvt<_Elem, char, mbstate_t> { public: explicit codecvt_utf8(size_t __refs = 0); ~codecvt_utf8(); }; template class codecvt_utf16 : public codecvt<_Elem, char, mbstate_t> { public: explicit codecvt_utf16(size_t __refs = 0); ~codecvt_utf16(); }; template class codecvt_utf8_utf16 : public codecvt<_Elem, char, mbstate_t> { public: explicit codecvt_utf8_utf16(size_t __refs = 0); ~codecvt_utf8_utf16(); }; # 154 "/usr/include/c++/10/codecvt" 3 template class __codecvt_utf8_base; template class __codecvt_utf16_base; template class __codecvt_utf8_utf16_base; template<> class __codecvt_utf8_base : public codecvt { public: typedef char16_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf8_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf8_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf8 : public __codecvt_utf8_base { public: explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf16_base : public codecvt { public: typedef char16_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf16_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf16_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf16 : public __codecvt_utf16_base { public: explicit codecvt_utf16(size_t __refs = 0) : __codecvt_utf16_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf8_utf16_base : public codecvt { public: typedef char16_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf8_utf16_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf8_utf16_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf8_utf16 : public __codecvt_utf8_utf16_base { public: explicit codecvt_utf8_utf16(size_t __refs = 0) : __codecvt_utf8_utf16_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf8_base : public codecvt { public: typedef char32_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf8_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf8_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf8 : public __codecvt_utf8_base { public: explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf16_base : public codecvt { public: typedef char32_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf16_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf16_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf16 : public __codecvt_utf16_base { public: explicit codecvt_utf16(size_t __refs = 0) : __codecvt_utf16_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf8_utf16_base : public codecvt { public: typedef char32_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf8_utf16_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf8_utf16_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf8_utf16 : public __codecvt_utf8_utf16_base { public: explicit codecvt_utf8_utf16(size_t __refs = 0) : __codecvt_utf8_utf16_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf8_base : public codecvt { public: typedef wchar_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf8_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf8_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf8 : public __codecvt_utf8_base { public: explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf16_base : public codecvt { public: typedef wchar_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf16_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf16_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf16 : public __codecvt_utf16_base { public: explicit codecvt_utf16(size_t __refs = 0) : __codecvt_utf16_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; template<> class __codecvt_utf8_utf16_base : public codecvt { public: typedef wchar_t intern_type; typedef char extern_type; typedef mbstate_t state_type; protected: __codecvt_utf8_utf16_base(unsigned long __maxcode, codecvt_mode __mode, size_t __refs) : codecvt(__refs), _M_maxcode(__maxcode), _M_mode(__mode) { } virtual ~__codecvt_utf8_utf16_base(); 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(); private: unsigned long _M_maxcode; codecvt_mode _M_mode; }; template class codecvt_utf8_utf16 : public __codecvt_utf8_utf16_base { public: explicit codecvt_utf8_utf16(size_t __refs = 0) : __codecvt_utf8_utf16_base(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } }; } # 82 "all-std.cxx" 2 # 1 "/usr/include/c++/10/locale" 1 3 # 36 "/usr/include/c++/10/locale" 3 # 37 "/usr/include/c++/10/locale" 3 # 1 "/usr/include/c++/10/bits/locale_facets_nonio.h" 1 3 # 37 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 # 38 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 # 1 "/usr/include/c++/10/ctime" 1 3 # 39 "/usr/include/c++/10/ctime" 3 # 40 "/usr/include/c++/10/ctime" 3 # 40 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 52 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 class time_base { public: enum dateorder { no_order, dmy, mdy, ymd, ydm }; }; template 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 __timepunct_cache<_CharT>::~__timepunct_cache() { if (_M_allocated) { } } template<> const char* __timepunct_cache::_S_timezones[14]; template<> const wchar_t* __timepunct_cache::_S_timezones[14]; template const _CharT* __timepunct_cache<_CharT>::_S_timezones[14]; template class __timepunct : public locale::facet { public: typedef _CharT __char_type; typedef __timepunct_cache<_CharT> __cache_type; protected: __cache_type* _M_data; __c_locale _M_c_locale_timepunct; const char* _M_name_timepunct; public: static locale::id id; explicit __timepunct(size_t __refs = 0); explicit __timepunct(__cache_type* __cache, size_t __refs = 0); # 206 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0); void _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format, const tm* __tm) const throw (); void _M_date_formats(const _CharT** __date) const { __date[0] = _M_data->_M_date_format; __date[1] = _M_data->_M_date_era_format; } void _M_time_formats(const _CharT** __time) const { __time[0] = _M_data->_M_time_format; __time[1] = _M_data->_M_time_era_format; } void _M_date_time_formats(const _CharT** __dt) const { __dt[0] = _M_data->_M_date_time_format; __dt[1] = _M_data->_M_date_time_era_format; } void _M_am_pm_format(const _CharT*) const { } void _M_am_pm(const _CharT** __ampm) const { __ampm[0] = _M_data->_M_am; __ampm[1] = _M_data->_M_pm; } void _M_days(const _CharT** __days) const { __days[0] = _M_data->_M_day1; __days[1] = _M_data->_M_day2; __days[2] = _M_data->_M_day3; __days[3] = _M_data->_M_day4; __days[4] = _M_data->_M_day5; __days[5] = _M_data->_M_day6; __days[6] = _M_data->_M_day7; } void _M_days_abbreviated(const _CharT** __days) const { __days[0] = _M_data->_M_aday1; __days[1] = _M_data->_M_aday2; __days[2] = _M_data->_M_aday3; __days[3] = _M_data->_M_aday4; __days[4] = _M_data->_M_aday5; __days[5] = _M_data->_M_aday6; __days[6] = _M_data->_M_aday7; } void _M_months(const _CharT** __months) const { __months[0] = _M_data->_M_month01; __months[1] = _M_data->_M_month02; __months[2] = _M_data->_M_month03; __months[3] = _M_data->_M_month04; __months[4] = _M_data->_M_month05; __months[5] = _M_data->_M_month06; __months[6] = _M_data->_M_month07; __months[7] = _M_data->_M_month08; __months[8] = _M_data->_M_month09; __months[9] = _M_data->_M_month10; __months[10] = _M_data->_M_month11; __months[11] = _M_data->_M_month12; } void _M_months_abbreviated(const _CharT** __months) const { __months[0] = _M_data->_M_amonth01; __months[1] = _M_data->_M_amonth02; __months[2] = _M_data->_M_amonth03; __months[3] = _M_data->_M_amonth04; __months[4] = _M_data->_M_amonth05; __months[5] = _M_data->_M_amonth06; __months[6] = _M_data->_M_amonth07; __months[7] = _M_data->_M_amonth08; __months[8] = _M_data->_M_amonth09; __months[9] = _M_data->_M_amonth10; __months[10] = _M_data->_M_amonth11; __months[11] = _M_data->_M_amonth12; } protected: virtual ~__timepunct(); void _M_initialize_timepunct(__c_locale __cloc = 0); }; template locale::id __timepunct<_CharT>::id; template<> void __timepunct::_M_initialize_timepunct(__c_locale __cloc); template<> void __timepunct::_M_put(char*, size_t, const char*, const tm*) const throw (); template<> void __timepunct::_M_initialize_timepunct(__c_locale __cloc); template<> void __timepunct::_M_put(wchar_t*, size_t, const wchar_t*, const tm*) const throw (); } # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/time_members.h" 1 3 # 37 "/usr/include/x86_64-linux-gnu/c++/10/bits/time_members.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template __timepunct<_CharT>::__timepunct(size_t __refs) : facet(__refs), _M_data(0), _M_c_locale_timepunct(0), _M_name_timepunct(_S_get_c_name()) { _M_initialize_timepunct(); } template __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs) : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0), _M_name_timepunct(_S_get_c_name()) { _M_initialize_timepunct(); } template __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s, size_t __refs) : facet(__refs), _M_data(0), _M_c_locale_timepunct(0), _M_name_timepunct(0) { if (__builtin_strcmp(__s, _S_get_c_name()) != 0) { const size_t __len = __builtin_strlen(__s) + 1; char* __tmp = new char[__len]; __builtin_memcpy(__tmp, __s, __len); _M_name_timepunct = __tmp; } else _M_name_timepunct = _S_get_c_name(); try { _M_initialize_timepunct(__cloc); } catch(...) { if (_M_name_timepunct != _S_get_c_name()) delete [] _M_name_timepunct; throw; } } template __timepunct<_CharT>::~__timepunct() { if (_M_name_timepunct != _S_get_c_name()) delete [] _M_name_timepunct; delete _M_data; _S_destroy_c_locale(_M_c_locale_timepunct); } } # 347 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { # 367 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template class time_get : public locale::facet, public time_base { public: typedef _CharT char_type; typedef _InIter iter_type; static locale::id id; # 388 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit time_get(size_t __refs = 0) : facet (__refs) { } # 405 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 dateorder date_order() const { return this->do_date_order(); } # 429 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get_time(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { return this->do_get_time(__beg, __end, __io, __err, __tm); } # 454 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get_date(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { return this->do_get_date(__beg, __end, __io, __err, __tm); } # 482 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get_weekday(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { return this->do_get_weekday(__beg, __end, __io, __err, __tm); } # 511 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get_monthname(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { return this->do_get_monthname(__beg, __end, __io, __err, __tm); } # 537 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get_year(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { return this->do_get_year(__beg, __end, __io, __err, __tm); } # 558 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 inline iter_type get(iter_type __s, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm, char __format, char __modifier = 0) const { return this->do_get(__s, __end, __io, __err, __tm, __format, __modifier); } # 585 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get(iter_type __s, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm, const char_type* __fmt, const char_type* __fmtend) const; protected: virtual ~time_get() { } # 605 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual dateorder do_date_order() const; # 623 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get_time(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const; # 642 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get_date(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const; # 661 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get_weekday(iter_type __beg, iter_type __end, ios_base&, ios_base::iostate& __err, tm* __tm) const; # 680 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get_monthname(iter_type __beg, iter_type __end, ios_base&, ios_base::iostate& __err, tm* __tm) const; # 699 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get_year(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const; # 722 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get(iter_type __s, iter_type __end, ios_base& __f, ios_base::iostate& __err, tm* __tm, char __format, char __modifier) const; iter_type _M_extract_num(iter_type __beg, iter_type __end, int& __member, int __min, int __max, size_t __len, ios_base& __io, ios_base::iostate& __err) const; iter_type _M_extract_name(iter_type __beg, iter_type __end, int& __member, const _CharT** __names, size_t __indexlen, ios_base& __io, ios_base::iostate& __err) const; iter_type _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member, const _CharT** __names, size_t __indexlen, ios_base& __io, ios_base::iostate& __err) const; iter_type _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm, const _CharT* __format) const; }; template locale::id time_get<_CharT, _InIter>::id; template class time_get_byname : public time_get<_CharT, _InIter> { public: typedef _CharT char_type; typedef _InIter iter_type; explicit time_get_byname(const char*, size_t __refs = 0) : time_get<_CharT, _InIter>(__refs) { } explicit time_get_byname(const string& __s, size_t __refs = 0) : time_get_byname(__s.c_str(), __refs) { } protected: virtual ~time_get_byname() { } }; } # 796 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template class time_put : public locale::facet { public: typedef _CharT char_type; typedef _OutIter iter_type; static locale::id id; # 817 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit time_put(size_t __refs = 0) : facet(__refs) { } # 836 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, const _CharT* __beg, const _CharT* __end) const; # 856 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, char __format, char __mod = 0) const { return this->do_put(__s, __io, __fill, __tm, __format, __mod); } protected: virtual ~time_put() { } # 883 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, char __format, char __mod) const; }; template locale::id time_put<_CharT, _OutIter>::id; template class time_put_byname : public time_put<_CharT, _OutIter> { public: typedef _CharT char_type; typedef _OutIter iter_type; explicit time_put_byname(const char*, size_t __refs = 0) : time_put<_CharT, _OutIter>(__refs) { } explicit time_put_byname(const string& __s, size_t __refs = 0) : time_put_byname(__s.c_str(), __refs) { } protected: virtual ~time_put_byname() { } }; # 928 "/usr/include/c++/10/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 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 __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache() { if (_M_allocated) { delete [] _M_grouping; delete [] _M_curr_symbol; delete [] _M_positive_sign; delete [] _M_negative_sign; } } namespace __cxx11 { # 1023 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template class moneypunct : public locale::facet, public money_base { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; typedef __moneypunct_cache<_CharT, _Intl> __cache_type; private: __cache_type* _M_data; public: static const bool intl = _Intl; static locale::id id; # 1052 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit moneypunct(size_t __refs = 0) : facet(__refs), _M_data(0) { _M_initialize_moneypunct(); } # 1065 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit moneypunct(__cache_type* __cache, size_t __refs = 0) : facet(__refs), _M_data(__cache) { _M_initialize_moneypunct(); } # 1080 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0) : facet(__refs), _M_data(0) { _M_initialize_moneypunct(__cloc, __s); } # 1094 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 char_type decimal_point() const { return this->do_decimal_point(); } # 1107 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 char_type thousands_sep() const { return this->do_thousands_sep(); } # 1137 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 string grouping() const { return this->do_grouping(); } # 1150 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 string_type curr_symbol() const { return this->do_curr_symbol(); } # 1167 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 string_type positive_sign() const { return this->do_positive_sign(); } # 1184 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 string_type negative_sign() const { return this->do_negative_sign(); } # 1200 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 int frac_digits() const { return this->do_frac_digits(); } # 1236 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 pattern pos_format() const { return this->do_pos_format(); } pattern neg_format() const { return this->do_neg_format(); } protected: virtual ~moneypunct(); # 1258 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual char_type do_decimal_point() const { return _M_data->_M_decimal_point; } # 1270 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual char_type do_thousands_sep() const { return _M_data->_M_thousands_sep; } # 1283 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual string do_grouping() const { return _M_data->_M_grouping; } # 1296 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual string_type do_curr_symbol() const { return _M_data->_M_curr_symbol; } # 1309 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual string_type do_positive_sign() const { return _M_data->_M_positive_sign; } # 1322 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual string_type do_negative_sign() const { return _M_data->_M_negative_sign; } # 1336 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual int do_frac_digits() const { return _M_data->_M_frac_digits; } # 1350 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual pattern do_pos_format() const { return _M_data->_M_pos_format; } # 1364 "/usr/include/c++/10/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 locale::id moneypunct<_CharT, _Intl>::id; template const bool moneypunct<_CharT, _Intl>::intl; template<> moneypunct::~moneypunct(); template<> moneypunct::~moneypunct(); template<> void moneypunct::_M_initialize_moneypunct(__c_locale, const char*); template<> void moneypunct::_M_initialize_moneypunct(__c_locale, const char*); template<> moneypunct::~moneypunct(); template<> moneypunct::~moneypunct(); template<> void moneypunct::_M_initialize_moneypunct(__c_locale, const char*); template<> void moneypunct::_M_initialize_moneypunct(__c_locale, const char*); template 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 const bool moneypunct_byname<_CharT, _Intl>::intl; } namespace __cxx11 { # 1467 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template class money_get : public locale::facet { public: typedef _CharT char_type; typedef _InIter iter_type; typedef basic_string<_CharT> string_type; static locale::id id; # 1489 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit money_get(size_t __refs = 0) : facet(__refs) { } # 1519 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, ios_base::iostate& __err, long double& __units) const { return this->do_get(__s, __end, __intl, __io, __err, __units); } # 1550 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, ios_base::iostate& __err, string_type& __digits) const { return this->do_get(__s, __end, __intl, __io, __err, __digits); } protected: virtual ~money_get() { } # 1574 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, ios_base::iostate& __err, long double& __units) const; # 1586 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, ios_base::iostate& __err, string_type& __digits) const; # 1598 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template iter_type _M_extract(iter_type __s, iter_type __end, ios_base& __io, ios_base::iostate& __err, string& __digits) const; }; template locale::id money_get<_CharT, _InIter>::id; # 1620 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template class money_put : public locale::facet { public: typedef _CharT char_type; typedef _OutIter iter_type; typedef basic_string<_CharT> string_type; static locale::id id; # 1641 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit money_put(size_t __refs = 0) : facet(__refs) { } # 1661 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, long double __units) const { return this->do_put(__s, __intl, __io, __fill, __units); } # 1684 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 iter_type put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, const string_type& __digits) const { return this->do_put(__s, __intl, __io, __fill, __digits); } protected: virtual ~money_put() { } # 1719 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, long double __units) const; # 1743 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, const string_type& __digits) const; # 1755 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template iter_type _M_insert(iter_type __s, ios_base& __io, char_type __fill, const string_type& __digits) const; }; template locale::id money_put<_CharT, _OutIter>::id; } struct messages_base { typedef int catalog; }; namespace __cxx11 { # 1798 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 template class messages : public locale::facet, public messages_base { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; protected: __c_locale _M_c_locale_messages; const char* _M_name_messages; public: static locale::id id; # 1826 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit messages(size_t __refs = 0); # 1840 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 explicit messages(__c_locale __cloc, const char* __s, size_t __refs = 0); # 1853 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 catalog open(const basic_string& __s, const locale& __loc) const { return this->do_open(__s, __loc); } # 1871 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 catalog open(const basic_string&, const locale&, const char*) const; # 1889 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 string_type get(catalog __c, int __set, int __msgid, const string_type& __s) const { return this->do_get(__c, __set, __msgid, __s); } # 1900 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 void close(catalog __c) const { return this->do_close(__c); } protected: virtual ~messages(); # 1920 "/usr/include/c++/10/bits/locale_facets_nonio.h" 3 virtual catalog do_open(const basic_string&, const locale&) const; # 1939 "/usr/include/c++/10/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(const_cast<_CharT*>(__msg.c_str())); } string_type _M_convert_from_char(char*) const { return string_type(); } }; template locale::id messages<_CharT>::id; template<> string messages::do_get(catalog, int, int, const string&) const; template<> wstring messages::do_get(catalog, int, int, const wstring&) const; template class messages_byname : public messages<_CharT> { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type; explicit messages_byname(const char* __s, size_t __refs = 0); explicit messages_byname(const string& __s, size_t __refs = 0) : messages_byname(__s.c_str(), __refs) { } protected: virtual ~messages_byname() { } }; } } # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/messages_members.h" 1 3 # 36 "/usr/include/x86_64-linux-gnu/c++/10/bits/messages_members.h" 3 # 1 "/usr/include/libintl.h" 1 3 4 # 34 "/usr/include/libintl.h" 3 4 extern "C" { extern char *gettext (const char *__msgid) throw () __attribute__ ((__format_arg__ (1))); extern char *dgettext (const char *__domainname, const char *__msgid) throw () __attribute__ ((__format_arg__ (2))); extern char *__dgettext (const char *__domainname, const char *__msgid) throw () __attribute__ ((__format_arg__ (2))); extern char *dcgettext (const char *__domainname, const char *__msgid, int __category) throw () __attribute__ ((__format_arg__ (2))); extern char *__dcgettext (const char *__domainname, const char *__msgid, int __category) throw () __attribute__ ((__format_arg__ (2))); extern char *ngettext (const char *__msgid1, const char *__msgid2, unsigned long int __n) throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2))); extern char *dngettext (const char *__domainname, const char *__msgid1, const char *__msgid2, unsigned long int __n) throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3))); extern char *dcngettext (const char *__domainname, const char *__msgid1, const char *__msgid2, unsigned long int __n, int __category) throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3))); extern char *textdomain (const char *__domainname) throw (); extern char *bindtextdomain (const char *__domainname, const char *__dirname) throw (); extern char *bind_textdomain_codeset (const char *__domainname, const char *__codeset) throw (); # 121 "/usr/include/libintl.h" 3 4 } # 37 "/usr/include/x86_64-linux-gnu/c++/10/bits/messages_members.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template messages<_CharT>::messages(size_t __refs) : facet(__refs), _M_c_locale_messages(_S_get_c_locale()), _M_name_messages(_S_get_c_name()) { } template messages<_CharT>::messages(__c_locale __cloc, const char* __s, size_t __refs) : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0) { if (__builtin_strcmp(__s, _S_get_c_name()) != 0) { const size_t __len = __builtin_strlen(__s) + 1; char* __tmp = new char[__len]; __builtin_memcpy(__tmp, __s, __len); _M_name_messages = __tmp; } else _M_name_messages = _S_get_c_name(); _M_c_locale_messages = _S_clone_c_locale(__cloc); } template typename messages<_CharT>::catalog messages<_CharT>::open(const basic_string& __s, const locale& __loc, const char* __dir) const { bindtextdomain(__s.c_str(), __dir); return this->do_open(__s, __loc); } template messages<_CharT>::~messages() { if (_M_name_messages != _S_get_c_name()) delete [] _M_name_messages; _S_destroy_c_locale(_M_c_locale_messages); } template typename messages<_CharT>::catalog messages<_CharT>::do_open(const basic_string& __s, const locale&) const { textdomain(__s.c_str()); return 0; } template void messages<_CharT>::do_close(catalog) const { } template messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs) : messages<_CharT>(__refs) { if (this->_M_name_messages != locale::facet::_S_get_c_name()) { delete [] this->_M_name_messages; if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0) { const size_t __len = __builtin_strlen(__s) + 1; char* __tmp = new char[__len]; __builtin_memcpy(__tmp, __s, __len); this->_M_name_messages = __tmp; } else this->_M_name_messages = locale::facet::_S_get_c_name(); } if (__builtin_strcmp(__s, "C") != 0 && __builtin_strcmp(__s, "POSIX") != 0) { this->_S_destroy_c_locale(this->_M_c_locale_messages); this->_S_create_c_locale(this->_M_c_locale_messages, __s); } } template<> typename messages::catalog messages::do_open(const basic_string&, const locale&) const; template<> void messages::do_close(catalog) const; template<> typename messages::catalog messages::do_open(const basic_string&, const locale&) const; template<> void messages::do_close(catalog) const; } # 2011 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3 # 1 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 1 3 # 33 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3 # 34 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template 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 void __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc) { const moneypunct<_CharT, _Intl>& __mp = use_facet >(__loc); _M_decimal_point = __mp.decimal_point(); _M_thousands_sep = __mp.thousands_sep(); _M_frac_digits = __mp.frac_digits(); char* __grouping = 0; _CharT* __curr_symbol = 0; _CharT* __positive_sign = 0; _CharT* __negative_sign = 0; try { const string& __g = __mp.grouping(); _M_grouping_size = __g.size(); __grouping = new char[_M_grouping_size]; __g.copy(__grouping, _M_grouping_size); _M_use_grouping = (_M_grouping_size && static_cast(__grouping[0]) > 0 && (__grouping[0] != __gnu_cxx::__numeric_traits::__max)); const basic_string<_CharT>& __cs = __mp.curr_symbol(); _M_curr_symbol_size = __cs.size(); __curr_symbol = new _CharT[_M_curr_symbol_size]; __cs.copy(__curr_symbol, _M_curr_symbol_size); const basic_string<_CharT>& __ps = __mp.positive_sign(); _M_positive_sign_size = __ps.size(); __positive_sign = new _CharT[_M_positive_sign_size]; __ps.copy(__positive_sign, _M_positive_sign_size); const basic_string<_CharT>& __ns = __mp.negative_sign(); _M_negative_sign_size = __ns.size(); __negative_sign = new _CharT[_M_negative_sign_size]; __ns.copy(__negative_sign, _M_negative_sign_size); _M_pos_format = __mp.pos_format(); _M_neg_format = __mp.neg_format(); const ctype<_CharT>& __ct = use_facet >(__loc); __ct.widen(money_base::_S_atoms, money_base::_S_atoms + money_base::_S_end, _M_atoms); _M_grouping = __grouping; _M_curr_symbol = __curr_symbol; _M_positive_sign = __positive_sign; _M_negative_sign = __negative_sign; _M_allocated = true; } catch(...) { delete [] __grouping; delete [] __curr_symbol; delete [] __positive_sign; delete [] __negative_sign; throw; } } namespace __cxx11 { template template _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 >(__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(__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(__p.field[0]) == money_base::sign) || (static_cast(__p.field[2]) == money_base::space))) || (__i == 2 && ((static_cast(__p.field[3]) == money_base::value) || (__mandatory_sign && (static_cast(__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(__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(__testdecfound ? __last_pos : __n); if (!std::__verify_grouping(__lc->_M_grouping, __lc->_M_grouping_size, __grouping_tmp)) __err |= ios_base::failbit; } if (__testdecfound && __n != __lc->_M_frac_digits) __testvalid = false; } if (!__testvalid) __err |= ios_base::failbit; else __units.swap(__res); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } # 368 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3 template _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(__beg, __end, __io, __err, __str) : _M_extract(__beg, __end, __io, __err, __str); std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale()); return __beg; } template _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 >(__loc); string __str; __beg = __intl ? _M_extract(__beg, __end, __io, __err, __str) : _M_extract(__beg, __end, __io, __err, __str); const size_type __len = __str.size(); if (__len) { __digits.resize(__len); __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]); } return __beg; } template template _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 >(__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(__io.width()); const bool __testipad = (__f == ios_base::internal && __len < __width); for (int __i = 0; __i < 4; ++__i) { const part __which = static_cast(__p.field[__i]); switch (__which) { case money_base::symbol: if (__io.flags() & ios_base::showbase) __res.append(__lc->_M_curr_symbol, __lc->_M_curr_symbol_size); break; case money_base::sign: if (__sign_size) __res += __sign[0]; break; case money_base::value: __res += __value; break; case money_base::space: if (__testipad) __res.append(__width - __len, __fill); else __res += __fill; break; case money_base::none: if (__testipad) __res.append(__width - __len, __fill); break; } } if (__sign_size > 1) __res.append(__sign + 1, __sign_size - 1); __len = __res.size(); if (__width > __len) { if (__f == ios_base::left) __res.append(__width - __len, __fill); else __res.insert(0, __width - __len, __fill); __len = __width; } __s = std::__write(__s, __res.data(), __len); } __io.width(0); return __s; } # 574 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3 template _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 >(__loc); int __cs_size = 64; char* __cs = static_cast(__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(__builtin_alloca(__cs_size)); __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, "%.*Lf", 0, __units); } # 606 "/usr/include/c++/10/bits/locale_facets_nonio.tcc" 3 string_type __digits(__len, char_type()); __ctype.widen(__cs, __cs + __len, &__digits[0]); return __intl ? _M_insert(__s, __io, __fill, __digits) : _M_insert(__s, __io, __fill, __digits); } template _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(__s, __io, __fill, __digits) : _M_insert(__s, __io, __fill, __digits); } } template time_base::dateorder time_get<_CharT, _InIter>::do_date_order() const { return time_base::no_order; } template _InIter time_get<_CharT, _InIter>:: _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm, const _CharT* __format) const { const locale& __loc = __io._M_getloc(); const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); const ctype<_CharT>& __ctype = use_facet >(__loc); const size_t __len = char_traits<_CharT>::length(__format); ios_base::iostate __tmperr = ios_base::goodbit; size_t __i = 0; for (; __beg != __end && __i < __len && !__tmperr; ++__i) { if (__ctype.narrow(__format[__i], 0) == '%') { char __c = __ctype.narrow(__format[++__i], 0); int __mem = 0; if (__c == 'E' || __c == 'O') __c = __ctype.narrow(__format[++__i], 0); switch (__c) { const char* __cs; _CharT __wcs[10]; case 'a': const char_type* __days1[7]; __tp._M_days_abbreviated(__days1); __beg = _M_extract_name(__beg, __end, __mem, __days1, 7, __io, __tmperr); if (!__tmperr) __tm->tm_wday = __mem; break; case 'A': const char_type* __days2[7]; __tp._M_days(__days2); __beg = _M_extract_name(__beg, __end, __mem, __days2, 7, __io, __tmperr); if (!__tmperr) __tm->tm_wday = __mem; break; case 'h': case 'b': const char_type* __months1[12]; __tp._M_months_abbreviated(__months1); __beg = _M_extract_name(__beg, __end, __mem, __months1, 12, __io, __tmperr); if (!__tmperr) __tm->tm_mon = __mem; break; case 'B': const char_type* __months2[12]; __tp._M_months(__months2); __beg = _M_extract_name(__beg, __end, __mem, __months2, 12, __io, __tmperr); if (!__tmperr) __tm->tm_mon = __mem; break; case 'c': const char_type* __dt[2]; __tp._M_date_time_formats(__dt); __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, __tm, __dt[0]); break; case 'd': __beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2, __io, __tmperr); if (!__tmperr) __tm->tm_mday = __mem; break; case 'e': if (__ctype.is(ctype_base::space, *__beg)) __beg = _M_extract_num(++__beg, __end, __mem, 1, 9, 1, __io, __tmperr); else __beg = _M_extract_num(__beg, __end, __mem, 10, 31, 2, __io, __tmperr); if (!__tmperr) __tm->tm_mday = __mem; break; case 'D': __cs = "%m/%d/%y"; __ctype.widen(__cs, __cs + 9, __wcs); __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, __tm, __wcs); break; case 'H': __beg = _M_extract_num(__beg, __end, __mem, 0, 23, 2, __io, __tmperr); if (!__tmperr) __tm->tm_hour = __mem; break; case 'I': __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2, __io, __tmperr); if (!__tmperr) __tm->tm_hour = __mem; break; case 'm': __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2, __io, __tmperr); if (!__tmperr) __tm->tm_mon = __mem - 1; break; case 'M': __beg = _M_extract_num(__beg, __end, __mem, 0, 59, 2, __io, __tmperr); if (!__tmperr) __tm->tm_min = __mem; break; case 'n': if (__ctype.narrow(*__beg, 0) == '\n') ++__beg; else __tmperr |= ios_base::failbit; break; case 'R': __cs = "%H:%M"; __ctype.widen(__cs, __cs + 6, __wcs); __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, __tm, __wcs); break; case 'S': __beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2, __io, __tmperr); if (!__tmperr) __tm->tm_sec = __mem; break; case 't': if (__ctype.narrow(*__beg, 0) == '\t') ++__beg; else __tmperr |= ios_base::failbit; break; case 'T': __cs = "%H:%M:%S"; __ctype.widen(__cs, __cs + 9, __wcs); __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, __tm, __wcs); break; case 'x': const char_type* __dates[2]; __tp._M_date_formats(__dates); __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, __tm, __dates[0]); break; case 'X': const char_type* __times[2]; __tp._M_time_formats(__times); __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, __tm, __times[0]); break; case 'y': case 'C': case 'Y': __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4, __io, __tmperr); if (!__tmperr) __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900; break; case 'Z': if (__ctype.is(ctype_base::upper, *__beg)) { int __tmp; __beg = _M_extract_name(__beg, __end, __tmp, __timepunct_cache<_CharT>::_S_timezones, 14, __io, __tmperr); if (__beg != __end && !__tmperr && __tmp == 0 && (*__beg == __ctype.widen('-') || *__beg == __ctype.widen('+'))) { __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2, __io, __tmperr); __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2, __io, __tmperr); } } else __tmperr |= ios_base::failbit; break; default: __tmperr |= ios_base::failbit; } } else { if (__format[__i] == *__beg) ++__beg; else __tmperr |= ios_base::failbit; } } if (__tmperr || __i != __len) __err |= ios_base::failbit; return __beg; } template _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 >(__loc); int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1); ++__min; size_t __i = 0; int __value = 0; for (; __beg != __end && __i < __len; ++__beg, (void)++__i) { const char __c = __ctype.narrow(*__beg, '*'); if (__c >= '0' && __c <= '9') { __value = __value * 10 + (__c - '0'); const int __valuec = __value * __mult; if (__valuec > __max || __valuec + __mult < __min) break; __mult /= 10; } else break; } if (__i == __len) __member = __value; else if (__len == 4 && __i == 2) __member = __value - 100; else __err |= ios_base::failbit; return __beg; } template _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 >(__loc); int* __matches = static_cast(__builtin_alloca(sizeof(int) * __indexlen)); size_t __nmatches = 0; size_t __pos = 0; bool __testvalid = true; const char_type* __name; if (__beg != __end) { const char_type __c = *__beg; for (size_t __i1 = 0; __i1 < __indexlen; ++__i1) if (__c == __names[__i1][0] || __c == __ctype.toupper(__names[__i1][0])) __matches[__nmatches++] = __i1; } while (__nmatches > 1) { size_t __minlen = __traits_type::length(__names[__matches[0]]); for (size_t __i2 = 1; __i2 < __nmatches; ++__i2) __minlen = std::min(__minlen, __traits_type::length(__names[__matches[__i2]])); ++__beg; ++__pos; if (__pos < __minlen && __beg != __end) for (size_t __i3 = 0; __i3 < __nmatches;) { __name = __names[__matches[__i3]]; if (!(__name[__pos] == *__beg)) __matches[__i3] = __matches[--__nmatches]; else ++__i3; } else break; } if (__nmatches == 1) { ++__beg; ++__pos; __name = __names[__matches[0]]; const size_t __len = __traits_type::length(__name); while (__pos < __len && __beg != __end && __name[__pos] == *__beg) ++__beg, (void)++__pos; if (__len == __pos) __member = __matches[0]; else __testvalid = false; } else __testvalid = false; if (!__testvalid) __err |= ios_base::failbit; return __beg; } template _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 >(__loc); int* __matches = static_cast(__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(__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 _InIter time_get<_CharT, _InIter>:: do_get_time(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { const locale& __loc = __io._M_getloc(); const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); const char_type* __times[2]; __tp._M_time_formats(__times); __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __times[0]); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template _InIter time_get<_CharT, _InIter>:: do_get_date(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { const locale& __loc = __io._M_getloc(); const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); const char_type* __dates[2]; __tp._M_date_formats(__dates); __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __dates[0]); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template _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 _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 _InIter time_get<_CharT, _InIter>:: do_get_year(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, tm* __tm) const { int __tmpyear; ios_base::iostate __tmperr = ios_base::goodbit; __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4, __io, __tmperr); if (!__tmperr) __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900; else __err |= ios_base::failbit; if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template 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 >(__loc); __err = ios_base::goodbit; while (__fmt != __fmtend && __err == ios_base::goodbit) { if (__s == __end) { __err = ios_base::eofbit | ios_base::failbit; break; } else if (__ctype.narrow(*__fmt, 0) == '%') { char __format; char __mod = 0; if (++__fmt == __fmtend) { __err = ios_base::failbit; break; } const char __c = __ctype.narrow(*__fmt, 0); if (__c != 'E' && __c != 'O') __format = __c; else if (++__fmt != __fmtend) { __mod = __c; __format = __ctype.narrow(*__fmt, 0); } else { __err = ios_base::failbit; break; } __s = this->do_get(__s, __end, __io, __err, __tm, __format, __mod); ++__fmt; } else if (__ctype.is(ctype_base::space, *__fmt)) { ++__fmt; while (__fmt != __fmtend && __ctype.is(ctype_base::space, *__fmt)) ++__fmt; while (__s != __end && __ctype.is(ctype_base::space, *__s)) ++__s; } else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) || __ctype.toupper(*__s) == __ctype.toupper(*__fmt)) { ++__s; ++__fmt; } else { __err = ios_base::failbit; break; } } return __s; } template 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 >(__loc); __err = ios_base::goodbit; char_type __fmt[4]; __fmt[0] = __ctype.widen('%'); if (!__mod) { __fmt[1] = __format; __fmt[2] = char_type(); } else { __fmt[1] = __mod; __fmt[2] = __format; __fmt[3] = char_type(); } __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt); if (__beg == __end) __err |= ios_base::eofbit; return __beg; } template _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 >(__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 _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 >(__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::length(__res)); } extern template class moneypunct; extern template class moneypunct; extern template class moneypunct_byname; extern template class moneypunct_byname; extern template class __cxx11:: money_get; extern template class __cxx11:: money_put; extern template class __timepunct; extern template class time_put; extern template class time_put_byname; extern template class time_get; extern template class time_get_byname; extern template class messages; extern template class messages_byname; extern template const moneypunct& use_facet >(const locale&); extern template const moneypunct& use_facet >(const locale&); extern template const money_put& use_facet >(const locale&); extern template const money_get& use_facet >(const locale&); extern template const __timepunct& use_facet<__timepunct >(const locale&); extern template const time_put& use_facet >(const locale&); extern template const time_get& use_facet >(const locale&); extern template const messages& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet<__timepunct >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template class moneypunct; extern template class moneypunct; extern template class moneypunct_byname; extern template class moneypunct_byname; extern template class __cxx11:: money_get; extern template class __cxx11:: money_put; extern template class __timepunct; extern template class time_put; extern template class time_put_byname; extern template class time_get; extern template class time_get_byname; extern template class messages; extern template class messages_byname; extern template const moneypunct& use_facet >(const locale&); extern template const moneypunct& use_facet >(const locale&); extern template const money_put& use_facet >(const locale&); extern template const money_get& use_facet >(const locale&); extern template const __timepunct& use_facet<__timepunct >(const locale&); extern template const time_put& use_facet >(const locale&); extern template const time_get& use_facet >(const locale&); extern template const messages& use_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet<__timepunct >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); extern template bool has_facet >(const locale&); } # 2016 "/usr/include/c++/10/bits/locale_facets_nonio.h" 2 3 # 42 "/usr/include/c++/10/locale" 2 3 # 1 "/usr/include/c++/10/bits/locale_conv.h" 1 3 # 43 "/usr/include/c++/10/bits/locale_conv.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { template 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()) if (__result == codecvt_base::noconv) { __outstr.assign(__first, __last); __count = __last - __first; return true; } __outstr.resize(__outchars); __count = __next - __first; return true; } template 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 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 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 inline bool __str_codecvt_out(const _CharT* __first, const _CharT* __last, basic_string& __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 inline bool __str_codecvt_out(const _CharT* __first, const _CharT* __last, basic_string& __outstr, const codecvt<_CharT, char, _State>& __cvt) { _State __state = {}; size_t __n; return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n); } template inline bool __str_codecvt_out_all(const _CharT* __first, const _CharT* __last, basic_string& __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 inline bool __str_codecvt_out(const _CharT* __first, const _CharT* __last, basic_string& __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 inline bool __str_codecvt_out(const _CharT* __first, const _CharT* __last, basic_string& __outstr, const codecvt<_CharT, char8_t, _State>& __cvt) { _State __state = {}; size_t __n; return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n); } namespace __cxx11 { template, typename _Byte_alloc = allocator> class wstring_convert { public: typedef basic_string, _Byte_alloc> byte_string; typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string; typedef typename _Codecvt::state_type state_type; typedef typename wide_string::traits_type::int_type int_type; wstring_convert() : _M_cvt(new _Codecvt()) { } explicit wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt) { if (!_M_cvt) __throw_logic_error("wstring_convert"); } # 264 "/usr/include/c++/10/bits/locale_conv.h" 3 wstring_convert(_Codecvt* __pcvt, state_type __state) : _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true) { if (!_M_cvt) __throw_logic_error("wstring_convert"); } explicit wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err = wide_string()) : _M_cvt(new _Codecvt), _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err), _M_with_strings(true) { if (!_M_cvt) __throw_logic_error("wstring_convert"); } ~wstring_convert() = default; wstring_convert(const wstring_convert&) = delete; wstring_convert& operator=(const wstring_convert&) = delete; wide_string from_bytes(char __byte) { char __bytes[2] = { __byte }; return from_bytes(__bytes, __bytes+1); } wide_string from_bytes(const char* __ptr) { return from_bytes(__ptr, __ptr+char_traits::length(__ptr)); } wide_string from_bytes(const byte_string& __str) { auto __ptr = __str.data(); return from_bytes(__ptr, __ptr + __str.size()); } wide_string from_bytes(const char* __first, const char* __last) { if (!_M_with_cvtstate) _M_state = state_type(); wide_string __out{ _M_wide_err_string.get_allocator() }; if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state, _M_count)) return __out; if (_M_with_strings) return _M_wide_err_string; __throw_range_error("wstring_convert::from_bytes"); } byte_string to_bytes(_Elem __wchar) { _Elem __wchars[2] = { __wchar }; return to_bytes(__wchars, __wchars+1); } byte_string to_bytes(const _Elem* __ptr) { return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr)); } byte_string to_bytes(const wide_string& __wstr) { auto __ptr = __wstr.data(); return to_bytes(__ptr, __ptr + __wstr.size()); } byte_string to_bytes(const _Elem* __first, const _Elem* __last) { if (!_M_with_cvtstate) _M_state = state_type(); byte_string __out{ _M_byte_err_string.get_allocator() }; if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state, _M_count)) return __out; if (_M_with_strings) return _M_byte_err_string; __throw_range_error("wstring_convert::to_bytes"); } size_t converted() const noexcept { return _M_count; } state_type state() const { return _M_state; } private: unique_ptr<_Codecvt> _M_cvt; byte_string _M_byte_err_string; wide_string _M_wide_err_string; state_type _M_state = state_type(); size_t _M_count = 0; bool _M_with_cvtstate = false; bool _M_with_strings = false; }; } template> class wbuffer_convert : public basic_streambuf<_Elem, _Tr> { typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf; public: typedef typename _Codecvt::state_type state_type; wbuffer_convert() : wbuffer_convert(nullptr) { } # 405 "/usr/include/c++/10/bits/locale_conv.h" 3 explicit wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type()) : _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state) { if (!_M_cvt) __throw_logic_error("wbuffer_convert"); _M_always_noconv = _M_cvt->always_noconv(); if (_M_buf) { this->setp(_M_put_area, _M_put_area + _S_buffer_length); this->setg(_M_get_area + _S_putback_length, _M_get_area + _S_putback_length, _M_get_area + _S_putback_length); } } ~wbuffer_convert() = default; wbuffer_convert(const wbuffer_convert&) = delete; wbuffer_convert& operator=(const wbuffer_convert&) = delete; streambuf* rdbuf() const noexcept { return _M_buf; } streambuf* rdbuf(streambuf *__bytebuf) noexcept { auto __prev = _M_buf; _M_buf = __bytebuf; return __prev; } state_type state() const noexcept { return _M_state; } protected: int sync() { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; } typename _Wide_streambuf::int_type overflow(typename _Wide_streambuf::int_type __out) { if (!_M_buf || !_M_conv_put()) return _Tr::eof(); else if (!_Tr::eq_int_type(__out, _Tr::eof())) return this->sputc(__out); return _Tr::not_eof(__out); } typename _Wide_streambuf::int_type underflow() { if (!_M_buf) return _Tr::eof(); if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get())) return _Tr::to_int_type(*this->gptr()); else return _Tr::eof(); } streamsize xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n) { if (!_M_buf || __n == 0) return 0; streamsize __done = 0; do { auto __nn = std::min(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(_M_get_buf); _Tr::copy(__outbuf, __get_buf, __nbytes); _M_unconv = 0; return true; } if ((_M_unconv = _M_get_buf + __nbytes - __bnext)) char_traits::move(_M_get_buf, __bnext, _M_unconv); this->setg(__outbuf, __outbuf, __outnext); return __result != codecvt_base::error; } bool _M_put(...) { return false; } bool _M_put(const char* __p, streamsize __n) { if (_M_buf->sputn(__p, __n) < __n) return false; return true; } bool _M_conv_put() { _Elem* const __first = this->pbase(); const _Elem* const __last = this->pptr(); const streamsize __pending = __last - __first; if (_M_always_noconv) return _M_put(__first, __pending); char __outbuf[2 * _S_buffer_length]; const _Elem* __next = __first; const _Elem* __start; do { __start = __next; char* __outnext = __outbuf; char* const __outlast = __outbuf + sizeof(__outbuf); auto __result = _M_cvt->out(_M_state, __next, __last, __next, __outnext, __outlast, __outnext); if (__result == codecvt_base::error) return false; else if (__result == codecvt_base::noconv) return _M_put(__next, __pending); if (!_M_put(__outbuf, __outnext - __outbuf)) return false; } while (__next != __last && __next != __start); if (__next != __last) _Tr::move(__first, __next, __last - __next); this->pbump(__first - __next); return __next != __first; } streambuf* _M_buf; unique_ptr<_Codecvt> _M_cvt; state_type _M_state; static const streamsize _S_buffer_length = 32; static const streamsize _S_putback_length = 3; _Elem _M_put_area[_S_buffer_length]; _Elem _M_get_area[_S_buffer_length]; streamsize _M_unconv = 0; char _M_get_buf[_S_buffer_length-_S_putback_length]; bool _M_always_noconv; }; } # 44 "/usr/include/c++/10/locale" 2 3 # 83 "all-std.cxx" 2 # 1 "/usr/include/c++/10/cstdio" 1 3 # 39 "/usr/include/c++/10/cstdio" 3 # 40 "/usr/include/c++/10/cstdio" 3 # 84 "all-std.cxx" 2 # 1 "/usr/include/c++/10/fstream" 1 3 # 36 "/usr/include/c++/10/fstream" 3 # 37 "/usr/include/c++/10/fstream" 3 # 1 "/usr/include/c++/10/cstdio" 1 3 # 39 "/usr/include/c++/10/cstdio" 3 # 40 "/usr/include/c++/10/cstdio" 3 # 42 "/usr/include/c++/10/fstream" 2 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/basic_file.h" 1 3 # 37 "/usr/include/x86_64-linux-gnu/c++/10/bits/basic_file.h" 3 # 38 "/usr/include/x86_64-linux-gnu/c++/10/bits/basic_file.h" 3 # 1 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++io.h" 1 3 # 35 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++io.h" 3 # 1 "/usr/include/c++/10/cstdio" 1 3 # 39 "/usr/include/c++/10/cstdio" 3 # 40 "/usr/include/c++/10/cstdio" 3 # 36 "/usr/include/x86_64-linux-gnu/c++/10/bits/c++io.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { typedef __gthread_mutex_t __c_lock; typedef FILE __c_file; } # 41 "/usr/include/x86_64-linux-gnu/c++/10/bits/basic_file.h" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template class __basic_file; template<> class __basic_file { __c_file* _M_cfile; bool _M_cfile_created; public: __basic_file(__c_lock* __lock = 0) throw (); __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created) { __rv._M_cfile = nullptr; __rv._M_cfile_created = false; } __basic_file& operator=(const __basic_file&) = delete; __basic_file& operator=(__basic_file&&) = delete; void swap(__basic_file& __f) noexcept { std::swap(_M_cfile, __f._M_cfile); std::swap(_M_cfile_created, __f._M_cfile_created); } __basic_file* open(const char* __name, ios_base::openmode __mode, int __prot = 0664); __basic_file* sys_open(__c_file* __file, ios_base::openmode); __basic_file* sys_open(int __fd, ios_base::openmode __mode) throw (); __basic_file* close(); __attribute__ ((__pure__)) bool is_open() const throw (); __attribute__ ((__pure__)) int fd() throw (); __attribute__ ((__pure__)) __c_file* file() throw (); ~__basic_file(); streamsize xsputn(const char* __s, streamsize __n); streamsize xsputn_2(const char* __s1, streamsize __n1, const char* __s2, streamsize __n2); streamsize xsgetn(char* __s, streamsize __n); streamoff seekoff(streamoff __off, ios_base::seekdir __way) throw (); int sync(); streamsize showmanyc(); }; } # 43 "/usr/include/c++/10/fstream" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template().make_preferred().filename())> using _If_fs_path = enable_if_t, _Result>; # 79 "/usr/include/c++/10/fstream" 3 template class basic_filebuf : public basic_streambuf<_CharT, _Traits> { template using __chk_state = __and_, is_copy_constructible<_Tp>, is_default_constructible<_Tp>>; static_assert(__chk_state::value, "state_type must be CopyAssignable, CopyConstructible" " and DefaultConstructible"); static_assert(is_same>::value, "pos_type must be fpos"); 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 __streambuf_type; typedef basic_filebuf __filebuf_type; typedef __basic_file __file_type; typedef typename traits_type::state_type __state_type; typedef codecvt __codecvt_type; friend class ios_base; protected: __c_lock _M_lock; __file_type _M_file; ios_base::openmode _M_mode; __state_type _M_state_beg; __state_type _M_state_cur; __state_type _M_state_last; char_type* _M_buf; size_t _M_buf_size; bool _M_buf_allocated; # 155 "/usr/include/c++/10/fstream" 3 bool _M_reading; bool _M_writing; char_type _M_pback; char_type* _M_pback_cur_save; char_type* _M_pback_end_save; bool _M_pback_init; const __codecvt_type* _M_codecvt; char* _M_ext_buf; streamsize _M_ext_buf_size; const char* _M_ext_next; char* _M_ext_end; void _M_create_pback() { if (!_M_pback_init) { _M_pback_cur_save = this->gptr(); _M_pback_end_save = this->egptr(); this->setg(&_M_pback, &_M_pback, &_M_pback + 1); _M_pback_init = true; } } void _M_destroy_pback() throw() { if (_M_pback_init) { _M_pback_cur_save += this->gptr() != this->eback(); this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); _M_pback_init = false; } } public: basic_filebuf(); basic_filebuf(const basic_filebuf&) = delete; basic_filebuf(basic_filebuf&&); virtual ~basic_filebuf() { try { this->close(); } catch(...) { } } basic_filebuf& operator=(const basic_filebuf&) = delete; basic_filebuf& operator=(basic_filebuf&&); void swap(basic_filebuf&); bool is_open() const throw() { return _M_file.is_open(); } # 309 "/usr/include/c++/10/fstream" 3 __filebuf_type* open(const char* __s, ios_base::openmode __mode); # 330 "/usr/include/c++/10/fstream" 3 __filebuf_type* open(const std::string& __s, ios_base::openmode __mode) { return open(__s.c_str(), __mode); } # 341 "/usr/include/c++/10/fstream" 3 template _If_fs_path<_Path, __filebuf_type*> open(const _Path& __s, ios_base::openmode __mode) { return open(__s.c_str(), __mode); } # 360 "/usr/include/c++/10/fstream" 3 __filebuf_type* close(); protected: void _M_allocate_internal_buffer(); void _M_destroy_internal_buffer() throw(); virtual streamsize showmanyc(); virtual int_type underflow(); virtual int_type pbackfail(int_type __c = _Traits::eof()); # 392 "/usr/include/c++/10/fstream" 3 virtual int_type overflow(int_type __c = _Traits::eof()); bool _M_convert_to_external(char_type*, streamsize); # 412 "/usr/include/c++/10/fstream" 3 virtual __streambuf_type* setbuf(char_type* __s, streamsize __n); virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode = ios_base::in | ios_base::out); virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode = ios_base::in | ios_base::out); pos_type _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); int _M_get_ext_pos(__state_type &__state); virtual int sync(); virtual void imbue(const locale& __loc); virtual streamsize xsgetn(char_type* __s, streamsize __n); virtual streamsize xsputn(const char_type* __s, streamsize __n); bool _M_terminate_output(); # 458 "/usr/include/c++/10/fstream" 3 void _M_set_buffer(streamsize __off) { const bool __testin = _M_mode & ios_base::in; const bool __testout = (_M_mode & ios_base::out || _M_mode & ios_base::app); if (__testin && __off > 0) this->setg(_M_buf, _M_buf, _M_buf + __off); else this->setg(_M_buf, _M_buf, _M_buf); if (__testout && __off == 0 && _M_buf_size > 1 ) this->setp(_M_buf, _M_buf + _M_buf_size - 1); else this->setp(0, 0); } }; # 491 "/usr/include/c++/10/fstream" 3 template class basic_ifstream : public basic_istream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_filebuf __filebuf_type; typedef basic_istream __istream_type; private: __filebuf_type _M_filebuf; public: # 518 "/usr/include/c++/10/fstream" 3 basic_ifstream() : __istream_type(), _M_filebuf() { this->init(&_M_filebuf); } # 528 "/usr/include/c++/10/fstream" 3 explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) : __istream_type(), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); } # 561 "/usr/include/c++/10/fstream" 3 explicit basic_ifstream(const std::string& __s, ios_base::openmode __mode = ios_base::in) : __istream_type(), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); } # 578 "/usr/include/c++/10/fstream" 3 template> basic_ifstream(const _Path& __s, ios_base::openmode __mode = ios_base::in) : basic_ifstream(__s.c_str(), __mode) { } basic_ifstream(const basic_ifstream&) = delete; basic_ifstream(basic_ifstream&& __rhs) : __istream_type(std::move(__rhs)), _M_filebuf(std::move(__rhs._M_filebuf)) { __istream_type::set_rdbuf(&_M_filebuf); } # 599 "/usr/include/c++/10/fstream" 3 ~basic_ifstream() { } basic_ifstream& operator=(const basic_ifstream&) = delete; basic_ifstream& operator=(basic_ifstream&& __rhs) { __istream_type::operator=(std::move(__rhs)); _M_filebuf = std::move(__rhs._M_filebuf); return *this; } void swap(basic_ifstream& __rhs) { __istream_type::swap(__rhs); _M_filebuf.swap(__rhs._M_filebuf); } # 631 "/usr/include/c++/10/fstream" 3 __filebuf_type* rdbuf() const { return const_cast<__filebuf_type*>(&_M_filebuf); } bool is_open() { return _M_filebuf.is_open(); } bool is_open() const { return _M_filebuf.is_open(); } # 657 "/usr/include/c++/10/fstream" 3 void open(const char* __s, ios_base::openmode __mode = ios_base::in) { if (!_M_filebuf.open(__s, __mode | ios_base::in)) this->setstate(ios_base::failbit); else this->clear(); } # 696 "/usr/include/c++/10/fstream" 3 void open(const std::string& __s, ios_base::openmode __mode = ios_base::in) { if (!_M_filebuf.open(__s, __mode | ios_base::in)) this->setstate(ios_base::failbit); else this->clear(); } # 716 "/usr/include/c++/10/fstream" 3 template _If_fs_path<_Path, void> open(const _Path& __s, ios_base::openmode __mode = ios_base::in) { open(__s.c_str(), __mode); } # 729 "/usr/include/c++/10/fstream" 3 void close() { if (!_M_filebuf.close()) this->setstate(ios_base::failbit); } }; # 752 "/usr/include/c++/10/fstream" 3 template class basic_ofstream : public basic_ostream<_CharT,_Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_filebuf __filebuf_type; typedef basic_ostream __ostream_type; private: __filebuf_type _M_filebuf; public: # 779 "/usr/include/c++/10/fstream" 3 basic_ofstream(): __ostream_type(), _M_filebuf() { this->init(&_M_filebuf); } # 789 "/usr/include/c++/10/fstream" 3 explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out) : __ostream_type(), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); } # 824 "/usr/include/c++/10/fstream" 3 explicit basic_ofstream(const std::string& __s, ios_base::openmode __mode = ios_base::out) : __ostream_type(), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); } # 841 "/usr/include/c++/10/fstream" 3 template> basic_ofstream(const _Path& __s, ios_base::openmode __mode = ios_base::out) : basic_ofstream(__s.c_str(), __mode) { } basic_ofstream(const basic_ofstream&) = delete; basic_ofstream(basic_ofstream&& __rhs) : __ostream_type(std::move(__rhs)), _M_filebuf(std::move(__rhs._M_filebuf)) { __ostream_type::set_rdbuf(&_M_filebuf); } # 862 "/usr/include/c++/10/fstream" 3 ~basic_ofstream() { } basic_ofstream& operator=(const basic_ofstream&) = delete; basic_ofstream& operator=(basic_ofstream&& __rhs) { __ostream_type::operator=(std::move(__rhs)); _M_filebuf = std::move(__rhs._M_filebuf); return *this; } void swap(basic_ofstream& __rhs) { __ostream_type::swap(__rhs); _M_filebuf.swap(__rhs._M_filebuf); } # 894 "/usr/include/c++/10/fstream" 3 __filebuf_type* rdbuf() const { return const_cast<__filebuf_type*>(&_M_filebuf); } bool is_open() { return _M_filebuf.is_open(); } bool is_open() const { return _M_filebuf.is_open(); } # 920 "/usr/include/c++/10/fstream" 3 void open(const char* __s, ios_base::openmode __mode = ios_base::out) { if (!_M_filebuf.open(__s, __mode | ios_base::out)) this->setstate(ios_base::failbit); else this->clear(); } # 959 "/usr/include/c++/10/fstream" 3 void open(const std::string& __s, ios_base::openmode __mode = ios_base::out) { if (!_M_filebuf.open(__s, __mode | ios_base::out)) this->setstate(ios_base::failbit); else this->clear(); } # 979 "/usr/include/c++/10/fstream" 3 template _If_fs_path<_Path, void> open(const _Path& __s, ios_base::openmode __mode = ios_base::out) { open(__s.c_str(), __mode); } # 992 "/usr/include/c++/10/fstream" 3 void close() { if (!_M_filebuf.close()) this->setstate(ios_base::failbit); } }; # 1015 "/usr/include/c++/10/fstream" 3 template class basic_fstream : public basic_iostream<_CharT, _Traits> { public: typedef _CharT char_type; typedef _Traits traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::pos_type pos_type; typedef typename traits_type::off_type off_type; typedef basic_filebuf __filebuf_type; typedef basic_ios __ios_type; typedef basic_iostream __iostream_type; private: __filebuf_type _M_filebuf; public: # 1043 "/usr/include/c++/10/fstream" 3 basic_fstream() : __iostream_type(), _M_filebuf() { this->init(&_M_filebuf); } explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out) : __iostream_type(0), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); } # 1082 "/usr/include/c++/10/fstream" 3 explicit basic_fstream(const std::string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out) : __iostream_type(0), _M_filebuf() { this->init(&_M_filebuf); this->open(__s, __mode); } template> basic_fstream(const _Path& __s, ios_base::openmode __mode = ios_base::in | ios_base::out) : basic_fstream(__s.c_str(), __mode) { } basic_fstream(const basic_fstream&) = delete; basic_fstream(basic_fstream&& __rhs) : __iostream_type(std::move(__rhs)), _M_filebuf(std::move(__rhs._M_filebuf)) { __iostream_type::set_rdbuf(&_M_filebuf); } # 1118 "/usr/include/c++/10/fstream" 3 ~basic_fstream() { } basic_fstream& operator=(const basic_fstream&) = delete; basic_fstream& operator=(basic_fstream&& __rhs) { __iostream_type::operator=(std::move(__rhs)); _M_filebuf = std::move(__rhs._M_filebuf); return *this; } void swap(basic_fstream& __rhs) { __iostream_type::swap(__rhs); _M_filebuf.swap(__rhs._M_filebuf); } # 1150 "/usr/include/c++/10/fstream" 3 __filebuf_type* rdbuf() const { return const_cast<__filebuf_type*>(&_M_filebuf); } bool is_open() { return _M_filebuf.is_open(); } bool is_open() const { return _M_filebuf.is_open(); } # 1176 "/usr/include/c++/10/fstream" 3 void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out) { if (!_M_filebuf.open(__s, __mode)) this->setstate(ios_base::failbit); else this->clear(); } # 1217 "/usr/include/c++/10/fstream" 3 void open(const std::string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out) { if (!_M_filebuf.open(__s, __mode)) this->setstate(ios_base::failbit); else this->clear(); } # 1238 "/usr/include/c++/10/fstream" 3 template _If_fs_path<_Path, void> open(const _Path& __s, ios_base::openmode __mode = ios_base::in | ios_base::out) { open(__s.c_str(), __mode); } # 1252 "/usr/include/c++/10/fstream" 3 void close() { if (!_M_filebuf.close()) this->setstate(ios_base::failbit); } }; template inline void swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y) { __x.swap(__y); } template inline void swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y) { __x.swap(__y); } template inline void swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y) { __x.swap(__y); } template inline void swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y) { __x.swap(__y); } } # 1 "/usr/include/c++/10/bits/fstream.tcc" 1 3 # 37 "/usr/include/c++/10/bits/fstream.tcc" 3 # 38 "/usr/include/c++/10/bits/fstream.tcc" 3 # 1 "/usr/include/c++/10/cerrno" 1 3 # 39 "/usr/include/c++/10/cerrno" 3 # 40 "/usr/include/c++/10/cerrno" 3 # 42 "/usr/include/c++/10/bits/fstream.tcc" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { template void basic_filebuf<_CharT, _Traits>:: _M_allocate_internal_buffer() { if (!_M_buf_allocated && !_M_buf) { _M_buf = new char_type[_M_buf_size]; _M_buf_allocated = true; } } template void basic_filebuf<_CharT, _Traits>:: _M_destroy_internal_buffer() throw() { if (_M_buf_allocated) { delete [] _M_buf; _M_buf = 0; _M_buf_allocated = false; } delete [] _M_ext_buf; _M_ext_buf = 0; _M_ext_buf_size = 0; _M_ext_next = 0; _M_ext_end = 0; } template basic_filebuf<_CharT, _Traits>:: basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock), _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(), _M_state_last(), _M_buf(0), _M_buf_size(8192), _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false), _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0), _M_ext_end(0) { if (has_facet<__codecvt_type>(this->_M_buf_locale)) _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale); } template basic_filebuf<_CharT, _Traits>:: basic_filebuf(basic_filebuf&& __rhs) : __streambuf_type(__rhs), _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock), _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))), _M_state_beg(std::move(__rhs._M_state_beg)), _M_state_cur(std::move(__rhs._M_state_cur)), _M_state_last(std::move(__rhs._M_state_last)), _M_buf(std::__exchange(__rhs._M_buf, nullptr)), _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)), _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)), _M_reading(std::__exchange(__rhs._M_reading, false)), _M_writing(std::__exchange(__rhs._M_writing, false)), _M_pback(__rhs._M_pback), _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)), _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)), _M_pback_init(std::__exchange(__rhs._M_pback_init, false)), _M_codecvt(__rhs._M_codecvt), _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)), _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)), _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)), _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr)) { __rhs._M_set_buffer(-1); __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg; } template basic_filebuf<_CharT, _Traits>& basic_filebuf<_CharT, _Traits>:: operator=(basic_filebuf&& __rhs) { this->close(); __streambuf_type::operator=(__rhs); _M_file.swap(__rhs._M_file); _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0)); _M_state_beg = std::move(__rhs._M_state_beg); _M_state_cur = std::move(__rhs._M_state_cur); _M_state_last = std::move(__rhs._M_state_last); _M_buf = std::__exchange(__rhs._M_buf, nullptr); _M_buf_size = std::__exchange(__rhs._M_buf_size, 1); _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false); _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr); _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0); _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr); _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr); _M_reading = std::__exchange(__rhs._M_reading, false); _M_writing = std::__exchange(__rhs._M_writing, false); _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr); _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr); _M_pback_init = std::__exchange(__rhs._M_pback_init, false); __rhs._M_set_buffer(-1); __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg; return *this; } template void basic_filebuf<_CharT, _Traits>:: swap(basic_filebuf& __rhs) { __streambuf_type::swap(__rhs); _M_file.swap(__rhs._M_file); std::swap(_M_mode, __rhs._M_mode); std::swap(_M_state_beg, __rhs._M_state_beg); std::swap(_M_state_cur, __rhs._M_state_cur); std::swap(_M_state_last, __rhs._M_state_last); std::swap(_M_buf, __rhs._M_buf); std::swap(_M_buf_size, __rhs._M_buf_size); std::swap(_M_buf_allocated, __rhs._M_buf_allocated); std::swap(_M_ext_buf, __rhs._M_ext_buf); std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size); std::swap(_M_ext_next, __rhs._M_ext_next); std::swap(_M_ext_end, __rhs._M_ext_end); std::swap(_M_reading, __rhs._M_reading); std::swap(_M_writing, __rhs._M_writing); std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save); std::swap(_M_pback_end_save, __rhs._M_pback_end_save); std::swap(_M_pback_init, __rhs._M_pback_init); } template typename basic_filebuf<_CharT, _Traits>::__filebuf_type* basic_filebuf<_CharT, _Traits>:: open(const char* __s, ios_base::openmode __mode) { __filebuf_type *__ret = 0; if (!this->is_open()) { _M_file.open(__s, __mode); if (this->is_open()) { _M_allocate_internal_buffer(); _M_mode = __mode; _M_reading = false; _M_writing = false; _M_set_buffer(-1); _M_state_last = _M_state_cur = _M_state_beg; if ((__mode & ios_base::ate) && this->seekoff(0, ios_base::end, __mode) == pos_type(off_type(-1))) this->close(); else __ret = this; } } return __ret; } # 247 "/usr/include/c++/10/bits/fstream.tcc" 3 template typename basic_filebuf<_CharT, _Traits>::__filebuf_type* basic_filebuf<_CharT, _Traits>:: close() { if (!this->is_open()) return 0; bool __testfail = false; { struct __close_sentry { basic_filebuf *__fb; __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { } ~__close_sentry () { __fb->_M_mode = ios_base::openmode(0); __fb->_M_pback_init = false; __fb->_M_destroy_internal_buffer(); __fb->_M_reading = false; __fb->_M_writing = false; __fb->_M_set_buffer(-1); __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg; } } __cs (this); try { if (!_M_terminate_output()) __testfail = true; } catch(...) { _M_file.close(); throw; } } if (!_M_file.close()) __testfail = true; if (__testfail) return 0; else return this; } template streamsize basic_filebuf<_CharT, _Traits>:: showmanyc() { streamsize __ret = -1; const bool __testin = _M_mode & ios_base::in; if (__testin && this->is_open()) { __ret = this->egptr() - this->gptr(); if (__check_facet(_M_codecvt).encoding() >= 0) __ret += _M_file.showmanyc() / _M_codecvt->max_length(); } return __ret; } template typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>:: underflow() { int_type __ret = traits_type::eof(); const bool __testin = _M_mode & ios_base::in; if (__testin) { if (_M_writing) { if (overflow() == traits_type::eof()) return __ret; _M_set_buffer(-1); _M_writing = false; } _M_destroy_pback(); if (this->gptr() < this->egptr()) return traits_type::to_int_type(*this->gptr()); const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; bool __got_eof = false; streamsize __ilen = 0; codecvt_base::result __r = codecvt_base::ok; if (__check_facet(_M_codecvt).always_noconv()) { __ilen = _M_file.xsgetn(reinterpret_cast(this->eback()), __buflen); if (__ilen == 0) __got_eof = true; } else { const int __enc = _M_codecvt->encoding(); streamsize __blen; streamsize __rlen; if (__enc > 0) __blen = __rlen = __buflen * __enc; else { __blen = __buflen + _M_codecvt->max_length() - 1; __rlen = __buflen; } const streamsize __remainder = _M_ext_end - _M_ext_next; __rlen = __rlen > __remainder ? __rlen - __remainder : 0; if (_M_reading && this->egptr() == this->eback() && __remainder) __rlen = 0; if (_M_ext_buf_size < __blen) { char* __buf = new char[__blen]; if (__remainder) __builtin_memcpy(__buf, _M_ext_next, __remainder); delete [] _M_ext_buf; _M_ext_buf = __buf; _M_ext_buf_size = __blen; } else if (__remainder) __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder); _M_ext_next = _M_ext_buf; _M_ext_end = _M_ext_buf + __remainder; _M_state_last = _M_state_cur; do { if (__rlen > 0) { if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size) { __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid") ); } streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen); if (__elen == 0) __got_eof = true; else if (__elen == -1) break; _M_ext_end += __elen; } char_type* __iend = this->eback(); if (_M_ext_next < _M_ext_end) __r = _M_codecvt->in(_M_state_cur, _M_ext_next, _M_ext_end, _M_ext_next, this->eback(), this->eback() + __buflen, __iend); if (__r == codecvt_base::noconv) { size_t __avail = _M_ext_end - _M_ext_buf; __ilen = std::min(__avail, __buflen); traits_type::copy(this->eback(), reinterpret_cast (_M_ext_buf), __ilen); _M_ext_next = _M_ext_buf + __ilen; } else __ilen = __iend - this->eback(); if (__r == codecvt_base::error) break; __rlen = 1; } while (__ilen == 0 && !__got_eof); } if (__ilen > 0) { _M_set_buffer(__ilen); _M_reading = true; __ret = traits_type::to_int_type(*this->gptr()); } else if (__got_eof) { _M_set_buffer(-1); _M_reading = false; if (__r == codecvt_base::partial) __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file") ); } else if (__r == codecvt_base::error) __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file") ); else __throw_ios_failure(("basic_filebuf::underflow " "error reading the file") , (*__errno_location ())); } return __ret; } template typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>:: pbackfail(int_type __i) { int_type __ret = traits_type::eof(); const bool __testin = _M_mode & ios_base::in; if (__testin) { if (_M_writing) { if (overflow() == traits_type::eof()) return __ret; _M_set_buffer(-1); _M_writing = false; } const bool __testpb = _M_pback_init; const bool __testeof = traits_type::eq_int_type(__i, __ret); int_type __tmp; if (this->eback() < this->gptr()) { this->gbump(-1); __tmp = traits_type::to_int_type(*this->gptr()); } else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1))) { __tmp = this->underflow(); if (traits_type::eq_int_type(__tmp, __ret)) return __ret; } else { return __ret; } if (!__testeof && traits_type::eq_int_type(__i, __tmp)) __ret = __i; else if (__testeof) __ret = traits_type::not_eof(__i); else if (!__testpb) { _M_create_pback(); _M_reading = true; *this->gptr() = traits_type::to_char_type(__i); __ret = __i; } } return __ret; } template typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>:: overflow(int_type __c) { int_type __ret = traits_type::eof(); const bool __testeof = traits_type::eq_int_type(__c, __ret); const bool __testout = (_M_mode & ios_base::out || _M_mode & ios_base::app); if (__testout) { if (_M_reading) { _M_destroy_pback(); const int __gptr_off = _M_get_ext_pos(_M_state_last); if (_M_seek(__gptr_off, ios_base::cur, _M_state_last) == pos_type(off_type(-1))) return __ret; } if (this->pbase() < this->pptr()) { if (!__testeof) { *this->pptr() = traits_type::to_char_type(__c); this->pbump(1); } if (_M_convert_to_external(this->pbase(), this->pptr() - this->pbase())) { _M_set_buffer(0); __ret = traits_type::not_eof(__c); } } else if (_M_buf_size > 1) { _M_set_buffer(0); _M_writing = true; if (!__testeof) { *this->pptr() = traits_type::to_char_type(__c); this->pbump(1); } __ret = traits_type::not_eof(__c); } else { char_type __conv = traits_type::to_char_type(__c); if (__testeof || _M_convert_to_external(&__conv, 1)) { _M_writing = true; __ret = traits_type::not_eof(__c); } } } return __ret; } template bool basic_filebuf<_CharT, _Traits>:: _M_convert_to_external(_CharT* __ibuf, streamsize __ilen) { streamsize __elen; streamsize __plen; if (__check_facet(_M_codecvt).always_noconv()) { __elen = _M_file.xsputn(reinterpret_cast(__ibuf), __ilen); __plen = __ilen; } else { streamsize __blen = __ilen * _M_codecvt->max_length(); char* __buf = static_cast(__builtin_alloca(__blen)); char* __bend; const char_type* __iend; codecvt_base::result __r; __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen, __iend, __buf, __buf + __blen, __bend); if (__r == codecvt_base::ok || __r == codecvt_base::partial) __blen = __bend - __buf; else if (__r == codecvt_base::noconv) { __buf = reinterpret_cast(__ibuf); __blen = __ilen; } else __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error") ); __elen = _M_file.xsputn(__buf, __blen); __plen = __blen; if (__r == codecvt_base::partial && __elen == __plen) { const char_type* __iresume = __iend; streamsize __rlen = this->pptr() - __iend; __r = _M_codecvt->out(_M_state_cur, __iresume, __iresume + __rlen, __iend, __buf, __buf + __blen, __bend); if (__r != codecvt_base::error) { __rlen = __bend - __buf; __elen = _M_file.xsputn(__buf, __rlen); __plen = __rlen; } else __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error") ); } } return __elen == __plen; } template streamsize basic_filebuf<_CharT, _Traits>:: xsgetn(_CharT* __s, streamsize __n) { streamsize __ret = 0; if (_M_pback_init) { if (__n > 0 && this->gptr() == this->eback()) { *__s++ = *this->gptr(); this->gbump(1); __ret = 1; --__n; } _M_destroy_pback(); } else if (_M_writing) { if (overflow() == traits_type::eof()) return __ret; _M_set_buffer(-1); _M_writing = false; } const bool __testin = _M_mode & ios_base::in; const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; if (__n > __buflen && __check_facet(_M_codecvt).always_noconv() && __testin) { const streamsize __avail = this->egptr() - this->gptr(); if (__avail != 0) { traits_type::copy(__s, this->gptr(), __avail); __s += __avail; this->setg(this->eback(), this->gptr() + __avail, this->egptr()); __ret += __avail; __n -= __avail; } streamsize __len; for (;;) { __len = _M_file.xsgetn(reinterpret_cast(__s), __n); if (__len == -1) __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file") , (*__errno_location ())); if (__len == 0) break; __n -= __len; __ret += __len; if (__n == 0) break; __s += __len; } if (__n == 0) { _M_reading = true; } else if (__len == 0) { _M_set_buffer(-1); _M_reading = false; } } else __ret += __streambuf_type::xsgetn(__s, __n); return __ret; } template streamsize basic_filebuf<_CharT, _Traits>:: xsputn(const _CharT* __s, streamsize __n) { streamsize __ret = 0; const bool __testout = (_M_mode & ios_base::out || _M_mode & ios_base::app); if (__check_facet(_M_codecvt).always_noconv() && __testout && !_M_reading) { const streamsize __chunk = 1ul << 10; streamsize __bufavail = this->epptr() - this->pptr(); if (!_M_writing && _M_buf_size > 1) __bufavail = _M_buf_size - 1; const streamsize __limit = std::min(__chunk, __bufavail); if (__n >= __limit) { const streamsize __buffill = this->pptr() - this->pbase(); const char* __buf = reinterpret_cast(this->pbase()); __ret = _M_file.xsputn_2(__buf, __buffill, reinterpret_cast(__s), __n); if (__ret == __buffill + __n) { _M_set_buffer(0); _M_writing = true; } if (__ret > __buffill) __ret -= __buffill; else __ret = 0; } else __ret = __streambuf_type::xsputn(__s, __n); } else __ret = __streambuf_type::xsputn(__s, __n); return __ret; } template typename basic_filebuf<_CharT, _Traits>::__streambuf_type* basic_filebuf<_CharT, _Traits>:: setbuf(char_type* __s, streamsize __n) { if (!this->is_open()) { if (__s == 0 && __n == 0) _M_buf_size = 1; else if (__s && __n > 0) { # 820 "/usr/include/c++/10/bits/fstream.tcc" 3 _M_buf = __s; _M_buf_size = __n; } } return this; } template typename basic_filebuf<_CharT, _Traits>::pos_type basic_filebuf<_CharT, _Traits>:: seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode) { int __width = 0; if (_M_codecvt) __width = _M_codecvt->encoding(); if (__width < 0) __width = 0; pos_type __ret = pos_type(off_type(-1)); const bool __testfail = __off != 0 && __width <= 0; if (this->is_open() && !__testfail) { bool __no_movement = __way == ios_base::cur && __off == 0 && (!_M_writing || _M_codecvt->always_noconv()); if (!__no_movement) _M_destroy_pback(); __state_type __state = _M_state_beg; off_type __computed_off = __off * __width; if (_M_reading && __way == ios_base::cur) { __state = _M_state_last; __computed_off += _M_get_ext_pos(__state); } if (!__no_movement) __ret = _M_seek(__computed_off, __way, __state); else { if (_M_writing) __computed_off = this->pptr() - this->pbase(); off_type __file_off = _M_file.seekoff(0, ios_base::cur); if (__file_off != off_type(-1)) { __ret = __file_off + __computed_off; __ret.state(__state); } } } return __ret; } template typename basic_filebuf<_CharT, _Traits>::pos_type basic_filebuf<_CharT, _Traits>:: seekpos(pos_type __pos, ios_base::openmode) { pos_type __ret = pos_type(off_type(-1)); if (this->is_open()) { _M_destroy_pback(); __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state()); } return __ret; } template typename basic_filebuf<_CharT, _Traits>::pos_type basic_filebuf<_CharT, _Traits>:: _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state) { pos_type __ret = pos_type(off_type(-1)); if (_M_terminate_output()) { off_type __file_off = _M_file.seekoff(__off, __way); if (__file_off != off_type(-1)) { _M_reading = false; _M_writing = false; _M_ext_next = _M_ext_end = _M_ext_buf; _M_set_buffer(-1); _M_state_cur = __state; __ret = __file_off; __ret.state(_M_state_cur); } } return __ret; } template int basic_filebuf<_CharT, _Traits>:: _M_get_ext_pos(__state_type& __state) { if (_M_codecvt->always_noconv()) return this->gptr() - this->egptr(); else { const int __gptr_off = _M_codecvt->length(__state, _M_ext_buf, _M_ext_next, this->gptr() - this->eback()); return _M_ext_buf + __gptr_off - _M_ext_end; } } template bool basic_filebuf<_CharT, _Traits>:: _M_terminate_output() { bool __testvalid = true; if (this->pbase() < this->pptr()) { const int_type __tmp = this->overflow(); if (traits_type::eq_int_type(__tmp, traits_type::eof())) __testvalid = false; } if (_M_writing && !__check_facet(_M_codecvt).always_noconv() && __testvalid) { const size_t __blen = 128; char __buf[__blen]; codecvt_base::result __r; streamsize __ilen = 0; do { char* __next; __r = _M_codecvt->unshift(_M_state_cur, __buf, __buf + __blen, __next); if (__r == codecvt_base::error) __testvalid = false; else if (__r == codecvt_base::ok || __r == codecvt_base::partial) { __ilen = __next - __buf; if (__ilen > 0) { const streamsize __elen = _M_file.xsputn(__buf, __ilen); if (__elen != __ilen) __testvalid = false; } } } while (__r == codecvt_base::partial && __ilen > 0 && __testvalid); if (__testvalid) { const int_type __tmp = this->overflow(); if (traits_type::eq_int_type(__tmp, traits_type::eof())) __testvalid = false; } } return __testvalid; } template int basic_filebuf<_CharT, _Traits>:: sync() { int __ret = 0; if (this->pbase() < this->pptr()) { const int_type __tmp = this->overflow(); if (traits_type::eq_int_type(__tmp, traits_type::eof())) __ret = -1; } return __ret; } template void basic_filebuf<_CharT, _Traits>:: imbue(const locale& __loc) { bool __testvalid = true; const __codecvt_type* _M_codecvt_tmp = 0; if (__builtin_expect(has_facet<__codecvt_type>(__loc), true)) _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc); if (this->is_open()) { if ((_M_reading || _M_writing) && __check_facet(_M_codecvt).encoding() == -1) __testvalid = false; else { if (_M_reading) { if (__check_facet(_M_codecvt).always_noconv()) { if (_M_codecvt_tmp && !__check_facet(_M_codecvt_tmp).always_noconv()) __testvalid = this->seekoff(0, ios_base::cur, _M_mode) != pos_type(off_type(-1)); } else { _M_ext_next = _M_ext_buf + _M_codecvt->length(_M_state_last, _M_ext_buf, _M_ext_next, this->gptr() - this->eback()); const streamsize __remainder = _M_ext_end - _M_ext_next; if (__remainder) __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder); _M_ext_next = _M_ext_buf; _M_ext_end = _M_ext_buf + __remainder; _M_set_buffer(-1); _M_state_last = _M_state_cur = _M_state_beg; } } else if (_M_writing && (__testvalid = _M_terminate_output())) _M_set_buffer(-1); } } if (__testvalid) _M_codecvt = _M_codecvt_tmp; else _M_codecvt = 0; } extern template class basic_filebuf; extern template class basic_ifstream; extern template class basic_ofstream; extern template class basic_fstream; extern template class basic_filebuf; extern template class basic_ifstream; extern template class basic_ofstream; extern template class basic_fstream; } # 1294 "/usr/include/c++/10/fstream" 2 3 # 85 "all-std.cxx" 2 # 1 "/usr/include/c++/10/iomanip" 1 3 # 36 "/usr/include/c++/10/iomanip" 3 # 37 "/usr/include/c++/10/iomanip" 3 # 45 "/usr/include/c++/10/iomanip" 3 # 1 "/usr/include/c++/10/bits/quoted_string.h" 1 3 # 33 "/usr/include/c++/10/bits/quoted_string.h" 3 # 34 "/usr/include/c++/10/bits/quoted_string.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template struct _Quoted_string { static_assert(is_reference<_String>::value || is_pointer<_String>::value, "String type must be pointer or reference"); _Quoted_string(_String __str, _CharT __del, _CharT __esc) : _M_string(__str), _M_delim{__del}, _M_escape{__esc} { } _Quoted_string& operator=(_Quoted_string&) = delete; _String _M_string; _CharT _M_delim; _CharT _M_escape; }; template struct _Quoted_string, _CharT> { _Quoted_string(basic_string_view<_CharT, _Traits> __str, _CharT __del, _CharT __esc) : _M_string(__str), _M_delim{__del}, _M_escape{__esc} { } _Quoted_string& operator=(_Quoted_string&) = delete; basic_string_view<_CharT, _Traits> _M_string; _CharT _M_delim; _CharT _M_escape; }; # 91 "/usr/include/c++/10/bits/quoted_string.h" 3 template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const _Quoted_string& __str) { std::basic_ostringstream<_CharT, _Traits> __ostr; __ostr << __str._M_delim; for (const _CharT* __c = __str._M_string; *__c; ++__c) { if (*__c == __str._M_delim || *__c == __str._M_escape) __ostr << __str._M_escape; __ostr << *__c; } __ostr << __str._M_delim; return __os << __ostr.str(); } template std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const _Quoted_string<_String, _CharT>& __str) { std::basic_ostringstream<_CharT, _Traits> __ostr; __ostr << __str._M_delim; for (auto __c : __str._M_string) { if (__c == __str._M_delim || __c == __str._M_escape) __ostr << __str._M_escape; __ostr << __c; } __ostr << __str._M_delim; return __os << __ostr.str(); } template std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, const _Quoted_string&, _CharT>& __str) { _CharT __c; __is >> __c; if (!__is.good()) return __is; if (__c != __str._M_delim) { __is.unget(); __is >> __str._M_string; return __is; } __str._M_string.clear(); std::ios_base::fmtflags __flags = __is.flags(__is.flags() & ~std::ios_base::skipws); do { __is >> __c; if (!__is.good()) break; if (__c == __str._M_escape) { __is >> __c; if (!__is.good()) break; } else if (__c == __str._M_delim) break; __str._M_string += __c; } while (true); __is.setf(__flags); return __is; } } } # 46 "/usr/include/c++/10/iomanip" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct _Resetiosflags { ios_base::fmtflags _M_mask; }; # 65 "/usr/include/c++/10/iomanip" 3 inline _Resetiosflags resetiosflags(ios_base::fmtflags __mask) { return { __mask }; } template inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f) { __is.setf(ios_base::fmtflags(0), __f._M_mask); return __is; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f) { __os.setf(ios_base::fmtflags(0), __f._M_mask); return __os; } struct _Setiosflags { ios_base::fmtflags _M_mask; }; # 95 "/usr/include/c++/10/iomanip" 3 inline _Setiosflags setiosflags(ios_base::fmtflags __mask) { return { __mask }; } template inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f) { __is.setf(__f._M_mask); return __is; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f) { __os.setf(__f._M_mask); return __os; } struct _Setbase { int _M_base; }; # 126 "/usr/include/c++/10/iomanip" 3 inline _Setbase setbase(int __base) { return { __base }; } template inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f) { __is.setf(__f._M_base == 8 ? ios_base::oct : __f._M_base == 10 ? ios_base::dec : __f._M_base == 16 ? ios_base::hex : ios_base::fmtflags(0), ios_base::basefield); return __is; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f) { __os.setf(__f._M_base == 8 ? ios_base::oct : __f._M_base == 10 ? ios_base::dec : __f._M_base == 16 ? ios_base::hex : ios_base::fmtflags(0), ios_base::basefield); return __os; } template struct _Setfill { _CharT _M_c; }; # 163 "/usr/include/c++/10/iomanip" 3 template inline _Setfill<_CharT> setfill(_CharT __c) { return { __c }; } template inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f) { __is.fill(__f._M_c); return __is; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f) { __os.fill(__f._M_c); return __os; } struct _Setprecision { int _M_n; }; # 194 "/usr/include/c++/10/iomanip" 3 inline _Setprecision setprecision(int __n) { return { __n }; } template inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f) { __is.precision(__f._M_n); return __is; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f) { __os.precision(__f._M_n); return __os; } struct _Setw { int _M_n; }; # 224 "/usr/include/c++/10/iomanip" 3 inline _Setw setw(int __n) { return { __n }; } template inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f) { __is.width(__f._M_n); return __is; } template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f) { __os.width(__f._M_n); return __os; } template struct _Get_money { _MoneyT& _M_mon; bool _M_intl; }; # 257 "/usr/include/c++/10/iomanip" 3 template inline _Get_money<_MoneyT> get_money(_MoneyT& __mon, bool __intl = false) { return { __mon, __intl }; } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f) { typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { typedef istreambuf_iterator<_CharT, _Traits> _Iter; typedef money_get<_CharT, _Iter> _MoneyGet; const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc()); __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl, __is, __err, __f._M_mon); } catch(__cxxabiv1::__forced_unwind&) { __is._M_setstate(ios_base::badbit); throw; } catch(...) { __is._M_setstate(ios_base::badbit); } if (__err) __is.setstate(__err); } return __is; } template struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; }; # 304 "/usr/include/c++/10/iomanip" 3 template inline _Put_money<_MoneyT> put_money(const _MoneyT& __mon, bool __intl = false) { return { __mon, __intl }; } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f) { typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { typedef ostreambuf_iterator<_CharT, _Traits> _Iter; typedef money_put<_CharT, _Iter> _MoneyPut; const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc()); if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os, __os.fill(), __f._M_mon).failed()) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { __os._M_setstate(ios_base::badbit); throw; } catch(...) { __os._M_setstate(ios_base::badbit); } if (__err) __os.setstate(__err); } return __os; } template struct _Put_time { const std::tm* _M_tmb; const _CharT* _M_fmt; }; # 356 "/usr/include/c++/10/iomanip" 3 template inline _Put_time<_CharT> put_time(const std::tm* __tmb, const _CharT* __fmt) { return { __tmb, __fmt }; } template basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f) { typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { typedef ostreambuf_iterator<_CharT, _Traits> _Iter; typedef time_put<_CharT, _Iter> _TimePut; const _CharT* const __fmt_end = __f._M_fmt + _Traits::length(__f._M_fmt); const _TimePut& __mp = use_facet<_TimePut>(__os.getloc()); if (__mp.put(_Iter(__os.rdbuf()), __os, __os.fill(), __f._M_tmb, __f._M_fmt, __fmt_end).failed()) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { __os._M_setstate(ios_base::badbit); throw; } catch(...) { __os._M_setstate(ios_base::badbit); } if (__err) __os.setstate(__err); } return __os; } template struct _Get_time { std::tm* _M_tmb; const _CharT* _M_fmt; }; # 411 "/usr/include/c++/10/iomanip" 3 template inline _Get_time<_CharT> get_time(std::tm* __tmb, const _CharT* __fmt) { return { __tmb, __fmt }; } template basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Get_time<_CharT> __f) { typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { typedef istreambuf_iterator<_CharT, _Traits> _Iter; typedef time_get<_CharT, _Iter> _TimeGet; const _CharT* const __fmt_end = __f._M_fmt + _Traits::length(__f._M_fmt); const _TimeGet& __mg = use_facet<_TimeGet>(__is.getloc()); __mg.get(_Iter(__is.rdbuf()), _Iter(), __is, __err, __f._M_tmb, __f._M_fmt, __fmt_end); } catch(__cxxabiv1::__forced_unwind&) { __is._M_setstate(ios_base::badbit); throw; } catch(...) { __is._M_setstate(ios_base::badbit); } if (__err) __is.setstate(__err); } return __is; } # 459 "/usr/include/c++/10/iomanip" 3 template inline auto quoted(const _CharT* __string, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) { return __detail::_Quoted_string(__string, __delim, __escape); } template inline auto quoted(const basic_string<_CharT, _Traits, _Alloc>& __string, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) { return __detail::_Quoted_string< const basic_string<_CharT, _Traits, _Alloc>&, _CharT>( __string, __delim, __escape); } template inline auto quoted(basic_string<_CharT, _Traits, _Alloc>& __string, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) { return __detail::_Quoted_string< basic_string<_CharT, _Traits, _Alloc>&, _CharT>( __string, __delim, __escape); } template inline auto quoted(basic_string_view<_CharT, _Traits> __sv, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) { return __detail::_Quoted_string< basic_string_view<_CharT, _Traits>, _CharT>(__sv, __delim, __escape); } # 508 "/usr/include/c++/10/iomanip" 3 extern template ostream& operator<<(ostream&, _Setfill); extern template ostream& operator<<(ostream&, _Setiosflags); extern template ostream& operator<<(ostream&, _Resetiosflags); extern template ostream& operator<<(ostream&, _Setbase); extern template ostream& operator<<(ostream&, _Setprecision); extern template ostream& operator<<(ostream&, _Setw); extern template istream& operator>>(istream&, _Setfill); extern template istream& operator>>(istream&, _Setiosflags); extern template istream& operator>>(istream&, _Resetiosflags); extern template istream& operator>>(istream&, _Setbase); extern template istream& operator>>(istream&, _Setprecision); extern template istream& operator>>(istream&, _Setw); extern template wostream& operator<<(wostream&, _Setfill); extern template wostream& operator<<(wostream&, _Setiosflags); extern template wostream& operator<<(wostream&, _Resetiosflags); extern template wostream& operator<<(wostream&, _Setbase); extern template wostream& operator<<(wostream&, _Setprecision); extern template wostream& operator<<(wostream&, _Setw); extern template wistream& operator>>(wistream&, _Setfill); extern template wistream& operator>>(wistream&, _Setiosflags); extern template wistream& operator>>(wistream&, _Resetiosflags); extern template wistream& operator>>(wistream&, _Setbase); extern template wistream& operator>>(wistream&, _Setprecision); extern template wistream& operator>>(wistream&, _Setw); } # 86 "all-std.cxx" 2 # 1 "/usr/include/c++/10/iostream" 1 3 # 36 "/usr/include/c++/10/iostream" 3 # 37 "/usr/include/c++/10/iostream" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 60 "/usr/include/c++/10/iostream" 3 extern istream cin; extern ostream cout; extern ostream cerr; extern ostream clog; extern wistream wcin; extern wostream wcout; extern wostream wcerr; extern wostream wclog; static ios_base::Init __ioinit; } # 89 "all-std.cxx" 2 # 1 "/usr/include/c++/10/filesystem" 1 3 # 33 "/usr/include/c++/10/filesystem" 3 # 34 "/usr/include/c++/10/filesystem" 3 # 44 "/usr/include/c++/10/filesystem" 3 # 1 "/usr/include/c++/10/bits/fs_fwd.h" 1 3 # 39 "/usr/include/c++/10/bits/fs_fwd.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace filesystem { inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } class file_status; namespace __cxx11 { class path; class filesystem_error; class directory_entry; class directory_iterator; class recursive_directory_iterator; } struct space_info { uintmax_t capacity; uintmax_t free; uintmax_t available; friend bool operator==(const space_info&, const space_info&) = default; }; enum class file_type : signed char { none = 0, not_found = -1, regular = 1, directory = 2, symlink = 3, block = 4, character = 5, fifo = 6, socket = 7, unknown = 8 }; enum class copy_options : unsigned short { none = 0, skip_existing = 1, overwrite_existing = 2, update_existing = 4, recursive = 8, copy_symlinks = 16, skip_symlinks = 32, directories_only = 64, create_symlinks = 128, create_hard_links = 256 }; constexpr copy_options operator&(copy_options __x, copy_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) & static_cast<__utype>(__y)); } constexpr copy_options operator|(copy_options __x, copy_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) | static_cast<__utype>(__y)); } constexpr copy_options operator^(copy_options __x, copy_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); } constexpr copy_options operator~(copy_options __x) noexcept { using __utype = typename std::underlying_type::type; return static_cast(~static_cast<__utype>(__x)); } inline copy_options& operator&=(copy_options& __x, copy_options __y) noexcept { return __x = __x & __y; } inline copy_options& operator|=(copy_options& __x, copy_options __y) noexcept { return __x = __x | __y; } inline copy_options& operator^=(copy_options& __x, copy_options __y) noexcept { return __x = __x ^ __y; } enum class perms : unsigned { none = 0, owner_read = 0400, owner_write = 0200, owner_exec = 0100, owner_all = 0700, group_read = 040, group_write = 020, group_exec = 010, group_all = 070, others_read = 04, others_write = 02, others_exec = 01, others_all = 07, all = 0777, set_uid = 04000, set_gid = 02000, sticky_bit = 01000, mask = 07777, unknown = 0xFFFF, }; constexpr perms operator&(perms __x, perms __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) & static_cast<__utype>(__y)); } constexpr perms operator|(perms __x, perms __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) | static_cast<__utype>(__y)); } constexpr perms operator^(perms __x, perms __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); } constexpr perms operator~(perms __x) noexcept { using __utype = typename std::underlying_type::type; return static_cast(~static_cast<__utype>(__x)); } inline perms& operator&=(perms& __x, perms __y) noexcept { return __x = __x & __y; } inline perms& operator|=(perms& __x, perms __y) noexcept { return __x = __x | __y; } inline perms& operator^=(perms& __x, perms __y) noexcept { return __x = __x ^ __y; } enum class perm_options : unsigned { replace = 0x1, add = 0x2, remove = 0x4, nofollow = 0x8 }; constexpr perm_options operator&(perm_options __x, perm_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) & static_cast<__utype>(__y)); } constexpr perm_options operator|(perm_options __x, perm_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) | static_cast<__utype>(__y)); } constexpr perm_options operator^(perm_options __x, perm_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); } constexpr perm_options operator~(perm_options __x) noexcept { using __utype = typename std::underlying_type::type; return static_cast(~static_cast<__utype>(__x)); } inline perm_options& operator&=(perm_options& __x, perm_options __y) noexcept { return __x = __x & __y; } inline perm_options& operator|=(perm_options& __x, perm_options __y) noexcept { return __x = __x | __y; } inline perm_options& operator^=(perm_options& __x, perm_options __y) noexcept { return __x = __x ^ __y; } enum class directory_options : unsigned char { none = 0, follow_directory_symlink = 1, skip_permission_denied = 2 }; constexpr directory_options operator&(directory_options __x, directory_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) & static_cast<__utype>(__y)); } constexpr directory_options operator|(directory_options __x, directory_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) | static_cast<__utype>(__y)); } constexpr directory_options operator^(directory_options __x, directory_options __y) noexcept { using __utype = typename std::underlying_type::type; return static_cast( static_cast<__utype>(__x) ^ static_cast<__utype>(__y)); } constexpr directory_options operator~(directory_options __x) noexcept { using __utype = typename std::underlying_type::type; return static_cast(~static_cast<__utype>(__x)); } inline directory_options& operator&=(directory_options& __x, directory_options __y) noexcept { return __x = __x & __y; } inline directory_options& operator|=(directory_options& __x, directory_options __y) noexcept { return __x = __x | __y; } inline directory_options& operator^=(directory_options& __x, directory_options __y) noexcept { return __x = __x ^ __y; } using file_time_type = __file_clock::time_point; void copy(const path& __from, const path& __to, copy_options __options); void copy(const path& __from, const path& __to, copy_options __options, error_code&); bool copy_file(const path& __from, const path& __to, copy_options __option); bool copy_file(const path& __from, const path& __to, copy_options __option, error_code&); path current_path(); bool exists(file_status) noexcept; bool is_other(file_status) noexcept; uintmax_t file_size(const path&); uintmax_t file_size(const path&, error_code&) noexcept; uintmax_t hard_link_count(const path&); uintmax_t hard_link_count(const path&, error_code&) noexcept; file_time_type last_write_time(const path&); file_time_type last_write_time(const path&, error_code&) noexcept; void permissions(const path&, perms, perm_options, error_code&) noexcept; path proximate(const path& __p, const path& __base, error_code& __ec); path proximate(const path& __p, const path& __base, error_code& __ec); path relative(const path& __p, const path& __base, error_code& __ec); file_status status(const path&); file_status status(const path&, error_code&) noexcept; bool status_known(file_status) noexcept; file_status symlink_status(const path&); file_status symlink_status(const path&, error_code&) noexcept; bool is_regular_file(file_status) noexcept; bool is_symlink(file_status) noexcept; } } # 45 "/usr/include/c++/10/filesystem" 2 3 # 1 "/usr/include/c++/10/bits/fs_path.h" 1 3 # 58 "/usr/include/c++/10/bits/fs_path.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace filesystem { namespace __cxx11 { class path; namespace __detail { template using __is_encoded_char = __is_one_of, char, char8_t, wchar_t, char16_t, char32_t>; template> using __is_path_iter_src = __and_<__is_encoded_char, std::is_base_of>; template static __is_path_iter_src<_Iter> __is_path_src(_Iter, int); template static __is_encoded_char<_CharT> __is_path_src(const basic_string<_CharT, _Traits, _Alloc>&, int); template static __is_encoded_char<_CharT> __is_path_src(const basic_string_view<_CharT, _Traits>&, int); template static std::false_type __is_path_src(const _Unknown&, ...); template struct __constructible_from; template struct __constructible_from<_Iter, _Iter> : __is_path_iter_src<_Iter> { }; template struct __constructible_from<_Source, void> : decltype(__is_path_src(std::declval<_Source>(), 0)) { }; template using _Path = typename std::enable_if<__and_<__not_, path>>, __not_>>, __constructible_from<_Tp1, _Tp2>>::value, path>::type; template _Source _S_range_begin(_Source __begin) { return __begin; } struct __null_terminated { }; template __null_terminated _S_range_end(_Source) { return {}; } template inline const _CharT* _S_range_begin(const basic_string<_CharT, _Traits, _Alloc>& __str) { return __str.data(); } template inline const _CharT* _S_range_end(const basic_string<_CharT, _Traits, _Alloc>& __str) { return __str.data() + __str.size(); } template inline const _CharT* _S_range_begin(const basic_string_view<_CharT, _Traits>& __str) { return __str.data(); } template inline const _CharT* _S_range_end(const basic_string_view<_CharT, _Traits>& __str) { return __str.data() + __str.size(); } template())), typename _Val = typename std::iterator_traits<_Iter>::value_type, typename _UnqualVal = std::remove_const_t<_Val>> using __value_type_is_char = std::enable_if_t, _UnqualVal>; template())), typename _Val = typename std::iterator_traits<_Iter>::value_type, typename _UnqualVal = std::remove_const_t<_Val>> using __value_type_is_char_or_char8_t = std::enable_if_t<__or_v< std::is_same<_UnqualVal, char> , std::is_same<_UnqualVal, char8_t> >, _UnqualVal>; } class path { public: # 195 "/usr/include/c++/10/bits/fs_path.h" 3 using value_type = char; static constexpr value_type preferred_separator = '/'; using string_type = std::basic_string; enum format : unsigned char { native_format, generic_format, auto_format }; path() noexcept { } path(const path& __p) = default; path(path&& __p) noexcept : _M_pathname(std::move(__p._M_pathname)), _M_cmpts(std::move(__p._M_cmpts)) { __p.clear(); } path(string_type&& __source, format = auto_format) : _M_pathname(std::move(__source)) { _M_split_cmpts(); } template> path(_Source const& __source, format = auto_format) : _M_pathname(_S_convert(__detail::_S_range_begin(__source), __detail::_S_range_end(__source))) { _M_split_cmpts(); } template> path(_InputIterator __first, _InputIterator __last, format = auto_format) : _M_pathname(_S_convert(__first, __last)) { _M_split_cmpts(); } template, typename _Require2 = __detail::__value_type_is_char<_Source>> path(_Source const& __source, const locale& __loc, format = auto_format) : _M_pathname(_S_convert_loc(__detail::_S_range_begin(__source), __detail::_S_range_end(__source), __loc)) { _M_split_cmpts(); } template, typename _Require2 = __detail::__value_type_is_char<_InputIterator>> path(_InputIterator __first, _InputIterator __last, const locale& __loc, format = auto_format) : _M_pathname(_S_convert_loc(__first, __last, __loc)) { _M_split_cmpts(); } ~path() = default; path& operator=(const path&); path& operator=(path&&) noexcept; path& operator=(string_type&& __source); path& assign(string_type&& __source); template __detail::_Path<_Source>& operator=(_Source const& __source) { return *this = path(__source); } template __detail::_Path<_Source>& assign(_Source const& __source) { return *this = path(__source); } template __detail::_Path<_InputIterator, _InputIterator>& assign(_InputIterator __first, _InputIterator __last) { return *this = path(__first, __last); } path& operator/=(const path& __p); template __detail::_Path<_Source>& operator/=(_Source const& __source) { _M_append(_S_convert(__detail::_S_range_begin(__source), __detail::_S_range_end(__source))); return *this; } template __detail::_Path<_Source>& append(_Source const& __source) { _M_append(_S_convert(__detail::_S_range_begin(__source), __detail::_S_range_end(__source))); return *this; } template __detail::_Path<_InputIterator, _InputIterator>& append(_InputIterator __first, _InputIterator __last) { _M_append(_S_convert(__first, __last)); return *this; } path& operator+=(const path& __x); path& operator+=(const string_type& __x); path& operator+=(const value_type* __x); path& operator+=(value_type __x); path& operator+=(basic_string_view __x); template __detail::_Path<_Source>& operator+=(_Source const& __x) { return concat(__x); } template __detail::_Path<_CharT*, _CharT*>& operator+=(_CharT __x); template __detail::_Path<_Source>& concat(_Source const& __x) { _M_concat(_S_convert(__detail::_S_range_begin(__x), __detail::_S_range_end(__x))); return *this; } template __detail::_Path<_InputIterator, _InputIterator>& concat(_InputIterator __first, _InputIterator __last) { _M_concat(_S_convert(__first, __last)); return *this; } void clear() noexcept { _M_pathname.clear(); _M_split_cmpts(); } path& make_preferred(); path& remove_filename(); path& replace_filename(const path& __replacement); path& replace_extension(const path& __replacement = path()); void swap(path& __rhs) noexcept; const string_type& native() const noexcept { return _M_pathname; } const value_type* c_str() const noexcept { return _M_pathname.c_str(); } operator string_type() const { return _M_pathname; } template, typename _Allocator = std::allocator<_CharT>> std::basic_string<_CharT, _Traits, _Allocator> string(const _Allocator& __a = _Allocator()) const; std::string string() const; std::wstring wstring() const; __attribute__((__abi_tag__("__u8"))) std::u8string u8string() const; std::u16string u16string() const; std::u32string u32string() const; template, typename _Allocator = std::allocator<_CharT>> std::basic_string<_CharT, _Traits, _Allocator> generic_string(const _Allocator& __a = _Allocator()) const; std::string generic_string() const; std::wstring generic_wstring() const; __attribute__((__abi_tag__("__u8"))) std::u8string generic_u8string() const; std::u16string generic_u16string() const; std::u32string generic_u32string() const; int compare(const path& __p) const noexcept; int compare(const string_type& __s) const noexcept; int compare(const value_type* __s) const noexcept; int compare(basic_string_view __s) const noexcept; path root_name() const; path root_directory() const; path root_path() const; path relative_path() const; path parent_path() const; path filename() const; path stem() const; path extension() const; [[nodiscard]] bool empty() const noexcept { return _M_pathname.empty(); } bool has_root_name() const noexcept; bool has_root_directory() const noexcept; bool has_root_path() const noexcept; bool has_relative_path() const noexcept; bool has_parent_path() const noexcept; bool has_filename() const noexcept; bool has_stem() const noexcept; bool has_extension() const noexcept; bool is_absolute() const noexcept; bool is_relative() const noexcept { return !is_absolute(); } path lexically_normal() const; path lexically_relative(const path& base) const; path lexically_proximate(const path& base) const; class iterator; using const_iterator = iterator; iterator begin() const; iterator end() const; template friend std::basic_ostream<_CharT, _Traits>& operator<<(std::basic_ostream<_CharT, _Traits>& __os, const path& __p) { __os << std::quoted(__p.string<_CharT, _Traits>()); return __os; } template friend std::basic_istream<_CharT, _Traits>& operator>>(std::basic_istream<_CharT, _Traits>& __is, path& __p) { std::basic_string<_CharT, _Traits> __tmp; if (__is >> std::quoted(__tmp)) __p = std::move(__tmp); return __is; } friend bool operator==(const path& __lhs, const path& __rhs) noexcept { return __lhs.compare(__rhs) == 0; } friend strong_ordering operator<=>(const path& __lhs, const path& __rhs) noexcept { return __lhs.compare(__rhs) <=> 0; } # 490 "/usr/include/c++/10/bits/fs_path.h" 3 friend path operator/(const path& __lhs, const path& __rhs) { path __result(__lhs); __result /= __rhs; return __result; } template, typename _CharT = typename std::remove_cv_t> static std::basic_string<_CharT> _S_string_from_iter(_InputIterator __source) { std::basic_string<_CharT> __str; for (_CharT __ch = *__source; __ch != _CharT(); __ch = *++__source) __str.push_back(__ch); return __str; } private: enum class _Type : unsigned char { _Multi = 0, _Root_name, _Root_dir, _Filename }; path(basic_string_view __str, _Type __type) : _M_pathname(__str) { ; _M_cmpts.type(__type); } enum class _Split { _Stem, _Extension }; void _M_append(basic_string_view); void _M_concat(basic_string_view); pair _M_find_extension() const noexcept; template struct _Cvt; static basic_string_view _S_convert(value_type* __src, __detail::__null_terminated) { return __src; } static basic_string_view _S_convert(const value_type* __src, __detail::__null_terminated) { return __src; } static basic_string_view _S_convert(value_type* __first, value_type* __last) { return {__first, __last - __first}; } static basic_string_view _S_convert(const value_type* __first, const value_type* __last) { return {__first, __last - __first}; } template static string_type _S_convert(_Iter __first, _Iter __last) { using __value_type = typename std::iterator_traits<_Iter>::value_type; return _Cvt::type>:: _S_convert(__first, __last); } template static string_type _S_convert(_InputIterator __src, __detail::__null_terminated) { auto __s = _S_string_from_iter(__src); return string_type(_S_convert(__s.data(), __s.data() + __s.size())); } static string_type _S_convert_loc(const char* __first, const char* __last, const std::locale& __loc); template static string_type _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc) { const std::string __str(__first, __last); return _S_convert_loc(__str.data(), __str.data()+__str.size(), __loc); } template static string_type _S_convert_loc(_InputIterator __src, __detail::__null_terminated, const std::locale& __loc) { const std::string __s = _S_string_from_iter(__src); return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc); } template static basic_string<_CharT, _Traits, _Allocator> _S_str_convert(basic_string_view, const _Allocator&); void _M_split_cmpts(); _Type _M_type() const noexcept { return _M_cmpts.type(); } string_type _M_pathname; struct _Cmpt; struct _List { using value_type = _Cmpt; using iterator = value_type*; using const_iterator = const value_type*; _List(); _List(const _List&); _List(_List&&) = default; _List& operator=(const _List&); _List& operator=(_List&&) = default; ~_List() = default; _Type type() const noexcept { return _Type(reinterpret_cast(_M_impl.get()) & 0x3); } void type(_Type) noexcept; int size() const noexcept; bool empty() const noexcept; void clear(); void swap(_List& __l) noexcept { _M_impl.swap(__l._M_impl); } int capacity() const noexcept; void reserve(int, bool); iterator begin() noexcept; iterator end() noexcept; const_iterator begin() const noexcept; const_iterator end() const noexcept; value_type& front() noexcept; value_type& back() noexcept; const value_type& front() const noexcept; const value_type& back() const noexcept; void pop_back(); void _M_erase_from(const_iterator __pos); struct _Impl; struct _Impl_deleter { void operator()(_Impl*) const noexcept; }; unique_ptr<_Impl, _Impl_deleter> _M_impl; }; _List _M_cmpts; struct _Parser; }; inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); } size_t hash_value(const path& __p) noexcept; class filesystem_error : public std::system_error { public: filesystem_error(const string& __what_arg, error_code __ec); filesystem_error(const string& __what_arg, const path& __p1, error_code __ec); filesystem_error(const string& __what_arg, const path& __p1, const path& __p2, error_code __ec); filesystem_error(const filesystem_error&) = default; filesystem_error& operator=(const filesystem_error&) = default; ~filesystem_error(); const path& path1() const noexcept; const path& path2() const noexcept; const char* what() const noexcept; private: struct _Impl; std::__shared_ptr _M_impl; }; template, typename _CharT = __detail::__value_type_is_char_or_char8_t<_InputIterator>> inline path u8path(_InputIterator __first, _InputIterator __last) { # 730 "/usr/include/c++/10/bits/fs_path.h" 3 return path{ __first, __last }; } template, typename _CharT = __detail::__value_type_is_char_or_char8_t<_Source>> inline path u8path(const _Source& __source) { # 761 "/usr/include/c++/10/bits/fs_path.h" 3 return path{ __source }; } struct path::_Cmpt : path { _Cmpt(basic_string_view __s, _Type __t, size_t __pos) : path(__s, __t), _M_pos(__pos) { } _Cmpt() : _M_pos(-1) { } size_t _M_pos; }; template<> struct path::_Cvt { template static string_type _S_convert(_Iter __first, _Iter __last) { return string_type{__first, __last}; } }; template<> struct path::_Cvt { template static string_type _S_convert(_Iter __first, _Iter __last) { return string_type(__first, __last); } }; template struct path::_Cvt { static string_type _S_convert(const _CharT* __f, const _CharT* __l) { # 839 "/usr/include/c++/10/bits/fs_path.h" 3 struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> { } __cvt; std::string __str; if (__str_codecvt_out_all(__f, __l, __str, __cvt)) return __str; (throw (filesystem_error( "Cannot convert character sequence", std::make_error_code(errc::illegal_byte_sequence)))) ; } static string_type _S_convert(_CharT* __f, _CharT* __l) { return _S_convert(const_cast(__f), const_cast(__l)); } template static string_type _S_convert(_Iter __first, _Iter __last) { const std::basic_string<_CharT> __str(__first, __last); return _S_convert(__str.data(), __str.data() + __str.size()); } template static string_type _S_convert(__gnu_cxx::__normal_iterator<_Iter, _Cont> __first, __gnu_cxx::__normal_iterator<_Iter, _Cont> __last) { return _S_convert(__first.base(), __last.base()); } }; class path::iterator { public: using difference_type = std::ptrdiff_t; using value_type = path; using reference = const path&; using pointer = const path*; using iterator_category = std::bidirectional_iterator_tag; iterator() : _M_path(nullptr), _M_cur(), _M_at_end() { } iterator(const iterator&) = default; iterator& operator=(const iterator&) = default; reference operator*() const; pointer operator->() const { return std::__addressof(**this); } iterator& operator++(); iterator operator++(int) { auto __tmp = *this; ++*this; return __tmp; } iterator& operator--(); iterator operator--(int) { auto __tmp = *this; --*this; return __tmp; } friend bool operator==(const iterator& __lhs, const iterator& __rhs) { return __lhs._M_equals(__rhs); } friend bool operator!=(const iterator& __lhs, const iterator& __rhs) { return !__lhs._M_equals(__rhs); } private: friend class path; bool _M_is_multi() const { return _M_path->_M_type() == _Type::_Multi; } friend difference_type __path_iter_distance(const iterator& __first, const iterator& __last) { ; ; if (__first._M_is_multi()) return std::distance(__first._M_cur, __last._M_cur); else if (__first._M_at_end == __last._M_at_end) return 0; else return __first._M_at_end ? -1 : 1; } friend void __path_iter_advance(iterator& __i, difference_type __n) { if (__n == 1) ++__i; else if (__n == -1) --__i; else if (__n != 0) { ; ; __i._M_cur += __n; } } iterator(const path* __path, path::_List::const_iterator __iter) : _M_path(__path), _M_cur(__iter), _M_at_end() { } iterator(const path* __path, bool __at_end) : _M_path(__path), _M_cur(), _M_at_end(__at_end) { } bool _M_equals(iterator) const; const path* _M_path; path::_List::const_iterator _M_cur; bool _M_at_end; }; inline path& path::operator=(path&& __p) noexcept { if (&__p == this) [[__unlikely__]] return *this; _M_pathname = std::move(__p._M_pathname); _M_cmpts = std::move(__p._M_cmpts); __p.clear(); return *this; } inline path& path::operator=(string_type&& __source) { return *this = path(std::move(__source)); } inline path& path::assign(string_type&& __source) { return *this = path(std::move(__source)); } inline path& path::operator+=(const string_type& __x) { _M_concat(__x); return *this; } inline path& path::operator+=(const value_type* __x) { _M_concat(__x); return *this; } inline path& path::operator+=(value_type __x) { _M_concat(basic_string_view(&__x, 1)); return *this; } inline path& path::operator+=(basic_string_view __x) { _M_concat(__x); return *this; } template inline __detail::_Path<_CharT*, _CharT*>& path::operator+=(_CharT __x) { auto* __addr = std::__addressof(__x); return concat(__addr, __addr + 1); } inline path& path::make_preferred() { return *this; } inline void path::swap(path& __rhs) noexcept { _M_pathname.swap(__rhs._M_pathname); _M_cmpts.swap(__rhs._M_cmpts); } template std::basic_string<_CharT, _Traits, _Allocator> path::_S_str_convert(basic_string_view __str, const _Allocator& __a) { static_assert(!is_same_v<_CharT, value_type>); using _WString = basic_string<_CharT, _Traits, _Allocator>; if (__str.size() == 0) return _WString(__a); # 1057 "/usr/include/c++/10/bits/fs_path.h" 3 const value_type* __first = __str.data(); const value_type* __last = __first + __str.size(); if constexpr (is_same_v<_CharT, char8_t>) return _WString(__first, __last, __a); else { _WString __wstr(__a); struct _UCvt : std::codecvt<_CharT, char, std::mbstate_t> { } __cvt; if (__str_codecvt_in_all(__first, __last, __wstr, __cvt)) return __wstr; } (throw (filesystem_error( "Cannot convert character sequence", std::make_error_code(errc::illegal_byte_sequence)))) ; } template inline basic_string<_CharT, _Traits, _Allocator> path::string(const _Allocator& __a) const { if constexpr (is_same_v<_CharT, value_type>) return { _M_pathname.c_str(), _M_pathname.length(), __a }; else return _S_str_convert<_CharT, _Traits>(_M_pathname, __a); } inline std::string path::string() const { return string(); } inline std::wstring path::wstring() const { return string(); } inline std::u8string path::u8string() const { return string(); } # 1126 "/usr/include/c++/10/bits/fs_path.h" 3 inline std::u16string path::u16string() const { return string(); } inline std::u32string path::u32string() const { return string(); } template inline std::basic_string<_CharT, _Traits, _Allocator> path::generic_string(const _Allocator& __a) const { const value_type __slash = '/'; using _Alloc2 = typename allocator_traits<_Allocator>::template rebind_alloc; basic_string, _Alloc2> __str(__a); if (_M_type() == _Type::_Root_dir) __str.assign(1, __slash); else { __str.reserve(_M_pathname.size()); bool __add_slash = false; for (auto& __elem : *this) { if (__add_slash) __str += __slash; __str += basic_string_view(__elem._M_pathname); __add_slash = __elem._M_type() == _Type::_Filename; } } if constexpr (is_same_v<_CharT, value_type>) return __str; else return _S_str_convert<_CharT, _Traits>(__str, __a); } inline std::string path::generic_string() const { return generic_string(); } inline std::wstring path::generic_wstring() const { return generic_string(); } inline std::u8string path::generic_u8string() const { return generic_string(); } inline std::u16string path::generic_u16string() const { return generic_string(); } inline std::u32string path::generic_u32string() const { return generic_string(); } inline int path::compare(const string_type& __s) const noexcept { return compare(basic_string_view(__s)); } inline int path::compare(const value_type* __s) const noexcept { return compare(basic_string_view(__s)); } inline path path::filename() const { if (empty()) return {}; else if (_M_type() == _Type::_Filename) return *this; else if (_M_type() == _Type::_Multi) { if (_M_pathname.back() == preferred_separator) return {}; auto& __last = *--end(); if (__last._M_type() == _Type::_Filename) return __last; } return {}; } inline path path::stem() const { auto ext = _M_find_extension(); if (ext.first && ext.second != 0) return path{ext.first->substr(0, ext.second)}; return {}; } inline path path::extension() const { auto ext = _M_find_extension(); if (ext.first && ext.second != string_type::npos) return path{ext.first->substr(ext.second)}; return {}; } inline bool path::has_stem() const noexcept { auto ext = _M_find_extension(); return ext.first && ext.second != 0; } inline bool path::has_extension() const noexcept { auto ext = _M_find_extension(); return ext.first && ext.second != string_type::npos; } inline bool path::is_absolute() const noexcept { return has_root_directory(); } inline path::iterator path::begin() const { if (_M_type() == _Type::_Multi) return iterator(this, _M_cmpts.begin()); return iterator(this, empty()); } inline path::iterator path::end() const { if (_M_type() == _Type::_Multi) return iterator(this, _M_cmpts.end()); return iterator(this, true); } inline path::iterator& path::iterator::operator++() { ; if (_M_path->_M_type() == _Type::_Multi) { ; ++_M_cur; } else { ; _M_at_end = true; } return *this; } inline path::iterator& path::iterator::operator--() { ; if (_M_path->_M_type() == _Type::_Multi) { ; --_M_cur; } else { ; _M_at_end = false; } return *this; } inline path::iterator::reference path::iterator::operator*() const { ; if (_M_path->_M_type() == _Type::_Multi) { ; return *_M_cur; } return *_M_path; } inline bool path::iterator::_M_equals(iterator __rhs) const { if (_M_path != __rhs._M_path) return false; if (_M_path == nullptr) return true; if (_M_path->_M_type() == path::_Type::_Multi) return _M_cur == __rhs._M_cur; return _M_at_end == __rhs._M_at_end; } } } inline ptrdiff_t distance(filesystem::path::iterator __first, filesystem::path::iterator __last) { return __path_iter_distance(__first, __last); } template void advance(filesystem::path::iterator& __i, _Distance __n) { __path_iter_advance(__i, static_cast(__n)); } extern template class __shared_ptr; } # 46 "/usr/include/c++/10/filesystem" 2 3 # 1 "/usr/include/c++/10/bits/fs_dir.h" 1 3 # 43 "/usr/include/c++/10/bits/fs_dir.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace filesystem { class file_status { public: file_status() noexcept : file_status(file_type::none) {} explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept : _M_type(__ft), _M_perms(__prms) { } file_status(const file_status&) noexcept = default; file_status(file_status&&) noexcept = default; ~file_status() = default; file_status& operator=(const file_status&) noexcept = default; file_status& operator=(file_status&&) noexcept = default; file_type type() const noexcept { return _M_type; } perms permissions() const noexcept { return _M_perms; } void type(file_type __ft) noexcept { _M_type = __ft; } void permissions(perms __prms) noexcept { _M_perms = __prms; } friend bool operator==(const file_status&, const file_status&) noexcept = default; private: file_type _M_type; perms _M_perms; }; namespace __cxx11 { struct _Dir; class directory_iterator; class recursive_directory_iterator; class directory_entry { public: directory_entry() noexcept = default; directory_entry(const directory_entry&) = default; directory_entry(directory_entry&&) noexcept = default; explicit directory_entry(const filesystem::path& __p) : _M_path(__p) { refresh(); } directory_entry(const filesystem::path& __p, error_code& __ec) : _M_path(__p) { refresh(__ec); if (__ec) _M_path.clear(); } ~directory_entry() = default; directory_entry& operator=(const directory_entry&) = default; directory_entry& operator=(directory_entry&&) noexcept = default; void assign(const filesystem::path& __p) { _M_path = __p; refresh(); } void assign(const filesystem::path& __p, error_code& __ec) { _M_path = __p; refresh(__ec); } void replace_filename(const filesystem::path& __p) { _M_path.replace_filename(__p); refresh(); } void replace_filename(const filesystem::path& __p, error_code& __ec) { _M_path.replace_filename(__p); refresh(__ec); } void refresh() { _M_type = symlink_status().type(); } void refresh(error_code& __ec) noexcept { _M_type = symlink_status(__ec).type(); } const filesystem::path& path() const noexcept { return _M_path; } operator const filesystem::path& () const noexcept { return _M_path; } bool exists() const { return filesystem::exists(file_status{_M_file_type()}); } bool exists(error_code& __ec) const noexcept { return filesystem::exists(file_status{_M_file_type(__ec)}); } bool is_block_file() const { return _M_file_type() == file_type::block; } bool is_block_file(error_code& __ec) const noexcept { return _M_file_type(__ec) == file_type::block; } bool is_character_file() const { return _M_file_type() == file_type::character; } bool is_character_file(error_code& __ec) const noexcept { return _M_file_type(__ec) == file_type::character; } bool is_directory() const { return _M_file_type() == file_type::directory; } bool is_directory(error_code& __ec) const noexcept { return _M_file_type(__ec) == file_type::directory; } bool is_fifo() const { return _M_file_type() == file_type::fifo; } bool is_fifo(error_code& __ec) const noexcept { return _M_file_type(__ec) == file_type::fifo; } bool is_other() const { return filesystem::is_other(file_status{_M_file_type()}); } bool is_other(error_code& __ec) const noexcept { return filesystem::is_other(file_status{_M_file_type(__ec)}); } bool is_regular_file() const { return _M_file_type() == file_type::regular; } bool is_regular_file(error_code& __ec) const noexcept { return _M_file_type(__ec) == file_type::regular; } bool is_socket() const { return _M_file_type() == file_type::socket; } bool is_socket(error_code& __ec) const noexcept { return _M_file_type(__ec) == file_type::socket; } bool is_symlink() const { if (_M_type != file_type::none) return _M_type == file_type::symlink; return symlink_status().type() == file_type::symlink; } bool is_symlink(error_code& __ec) const noexcept { if (_M_type != file_type::none) return _M_type == file_type::symlink; return symlink_status(__ec).type() == file_type::symlink; } uintmax_t file_size() const { return filesystem::file_size(_M_path); } uintmax_t file_size(error_code& __ec) const noexcept { return filesystem::file_size(_M_path, __ec); } uintmax_t hard_link_count() const { return filesystem::hard_link_count(_M_path); } uintmax_t hard_link_count(error_code& __ec) const noexcept { return filesystem::hard_link_count(_M_path, __ec); } file_time_type last_write_time() const { return filesystem::last_write_time(_M_path); } file_time_type last_write_time(error_code& __ec) const noexcept { return filesystem::last_write_time(_M_path, __ec); } file_status status() const { return filesystem::status(_M_path); } file_status status(error_code& __ec) const noexcept { return filesystem::status(_M_path, __ec); } file_status symlink_status() const { return filesystem::symlink_status(_M_path); } file_status symlink_status(error_code& __ec) const noexcept { return filesystem::symlink_status(_M_path, __ec); } bool operator==(const directory_entry& __rhs) const noexcept { return _M_path == __rhs._M_path; } strong_ordering operator<=>(const directory_entry& __rhs) const noexcept { return _M_path <=> __rhs._M_path; } # 314 "/usr/include/c++/10/bits/fs_dir.h" 3 private: friend class _Dir; friend class directory_iterator; friend class recursive_directory_iterator; template friend basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const directory_entry& __d) { return __os << __d.path(); } directory_entry(const filesystem::path& __p, file_type __t) : _M_path(__p), _M_type(__t) { } file_type _M_file_type() const { if (_M_type != file_type::none && _M_type != file_type::symlink) return _M_type; return status().type(); } file_type _M_file_type(error_code& __ec) const noexcept { if (_M_type != file_type::none && _M_type != file_type::symlink) { __ec.clear(); return _M_type; } return status(__ec).type(); } filesystem::path _M_path; file_type _M_type = file_type::none; }; struct __directory_iterator_proxy { const directory_entry& operator*() const& noexcept { return _M_entry; } directory_entry operator*() && noexcept { return std::move(_M_entry); } private: friend class directory_iterator; friend class recursive_directory_iterator; explicit __directory_iterator_proxy(const directory_entry& __e) : _M_entry(__e) { } directory_entry _M_entry; }; class directory_iterator { public: typedef directory_entry value_type; typedef ptrdiff_t difference_type; typedef const directory_entry* pointer; typedef const directory_entry& reference; typedef input_iterator_tag iterator_category; directory_iterator() = default; explicit directory_iterator(const path& __p) : directory_iterator(__p, directory_options::none, nullptr) { } directory_iterator(const path& __p, directory_options __options) : directory_iterator(__p, __options, nullptr) { } directory_iterator(const path& __p, error_code& __ec) : directory_iterator(__p, directory_options::none, __ec) { } directory_iterator(const path& __p, directory_options __options, error_code& __ec) : directory_iterator(__p, __options, &__ec) { } directory_iterator(const directory_iterator& __rhs) = default; directory_iterator(directory_iterator&& __rhs) noexcept = default; ~directory_iterator() = default; directory_iterator& operator=(const directory_iterator& __rhs) = default; directory_iterator& operator=(directory_iterator&& __rhs) noexcept = default; const directory_entry& operator*() const noexcept; const directory_entry* operator->() const noexcept { return &**this; } directory_iterator& operator++(); directory_iterator& increment(error_code& __ec); __directory_iterator_proxy operator++(int) { __directory_iterator_proxy __pr{**this}; ++*this; return __pr; } private: directory_iterator(const path&, directory_options, error_code*); friend bool operator==(const directory_iterator& __lhs, const directory_iterator& __rhs) noexcept { return !__rhs._M_dir.owner_before(__lhs._M_dir) && !__lhs._M_dir.owner_before(__rhs._M_dir); } friend bool operator!=(const directory_iterator& __lhs, const directory_iterator& __rhs) noexcept { return !(__lhs == __rhs); } friend class recursive_directory_iterator; std::__shared_ptr<_Dir> _M_dir; }; inline directory_iterator begin(directory_iterator __iter) noexcept { return __iter; } inline directory_iterator end(directory_iterator) noexcept { return directory_iterator(); } class recursive_directory_iterator { public: typedef directory_entry value_type; typedef ptrdiff_t difference_type; typedef const directory_entry* pointer; typedef const directory_entry& reference; typedef input_iterator_tag iterator_category; recursive_directory_iterator() = default; explicit recursive_directory_iterator(const path& __p) : recursive_directory_iterator(__p, directory_options::none, nullptr) { } recursive_directory_iterator(const path& __p, directory_options __options) : recursive_directory_iterator(__p, __options, nullptr) { } recursive_directory_iterator(const path& __p, directory_options __options, error_code& __ec) : recursive_directory_iterator(__p, __options, &__ec) { } recursive_directory_iterator(const path& __p, error_code& __ec) : recursive_directory_iterator(__p, directory_options::none, &__ec) { } recursive_directory_iterator( const recursive_directory_iterator&) = default; recursive_directory_iterator(recursive_directory_iterator&&) = default; ~recursive_directory_iterator(); directory_options options() const noexcept; int depth() const noexcept; bool recursion_pending() const noexcept; const directory_entry& operator*() const noexcept; const directory_entry* operator->() const noexcept { return &**this; } recursive_directory_iterator& operator=(const recursive_directory_iterator& __rhs) noexcept; recursive_directory_iterator& operator=(recursive_directory_iterator&& __rhs) noexcept; recursive_directory_iterator& operator++(); recursive_directory_iterator& increment(error_code& __ec); __directory_iterator_proxy operator++(int) { __directory_iterator_proxy __pr{**this}; ++*this; return __pr; } void pop(); void pop(error_code&); void disable_recursion_pending() noexcept; private: recursive_directory_iterator(const path&, directory_options, error_code*); friend bool operator==(const recursive_directory_iterator& __lhs, const recursive_directory_iterator& __rhs) noexcept { return !__rhs._M_dirs.owner_before(__lhs._M_dirs) && !__lhs._M_dirs.owner_before(__rhs._M_dirs); } friend bool operator!=(const recursive_directory_iterator& __lhs, const recursive_directory_iterator& __rhs) noexcept { return !(__lhs == __rhs); } struct _Dir_stack; std::__shared_ptr<_Dir_stack> _M_dirs; }; inline recursive_directory_iterator begin(recursive_directory_iterator __iter) noexcept { return __iter; } inline recursive_directory_iterator end(recursive_directory_iterator) noexcept { return recursive_directory_iterator(); } } } extern template class __shared_ptr; extern template class __shared_ptr; } # 47 "/usr/include/c++/10/filesystem" 2 3 # 1 "/usr/include/c++/10/bits/fs_ops.h" 1 3 # 37 "/usr/include/c++/10/bits/fs_ops.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace filesystem { path absolute(const path& __p); path absolute(const path& __p, error_code& __ec); path canonical(const path& __p); path canonical(const path& __p, error_code& __ec); inline void copy(const path& __from, const path& __to) { copy(__from, __to, copy_options::none); } inline void copy(const path& __from, const path& __to, error_code& __ec) { copy(__from, __to, copy_options::none, __ec); } void copy(const path& __from, const path& __to, copy_options __options); void copy(const path& __from, const path& __to, copy_options __options, error_code& __ec); inline bool copy_file(const path& __from, const path& __to) { return copy_file(__from, __to, copy_options::none); } inline bool copy_file(const path& __from, const path& __to, error_code& __ec) { return copy_file(__from, __to, copy_options::none, __ec); } bool copy_file(const path& __from, const path& __to, copy_options __option); bool copy_file(const path& __from, const path& __to, copy_options __option, error_code& __ec); void copy_symlink(const path& __existing_symlink, const path& __new_symlink); void copy_symlink(const path& __existing_symlink, const path& __new_symlink, error_code& __ec) noexcept; bool create_directories(const path& __p); bool create_directories(const path& __p, error_code& __ec); bool create_directory(const path& __p); bool create_directory(const path& __p, error_code& __ec) noexcept; bool create_directory(const path& __p, const path& attributes); bool create_directory(const path& __p, const path& attributes, error_code& __ec) noexcept; void create_directory_symlink(const path& __to, const path& __new_symlink); void create_directory_symlink(const path& __to, const path& __new_symlink, error_code& __ec) noexcept; void create_hard_link(const path& __to, const path& __new_hard_link); void create_hard_link(const path& __to, const path& __new_hard_link, error_code& __ec) noexcept; void create_symlink(const path& __to, const path& __new_symlink); void create_symlink(const path& __to, const path& __new_symlink, error_code& __ec) noexcept; path current_path(); path current_path(error_code& __ec); void current_path(const path& __p); void current_path(const path& __p, error_code& __ec) noexcept; bool equivalent(const path& __p1, const path& __p2); bool equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept; inline bool exists(file_status __s) noexcept { return status_known(__s) && __s.type() != file_type::not_found; } inline bool exists(const path& __p) { return exists(status(__p)); } inline bool exists(const path& __p, error_code& __ec) noexcept { auto __s = status(__p, __ec); if (status_known(__s)) { __ec.clear(); return __s.type() != file_type::not_found; } return false; } uintmax_t file_size(const path& __p); uintmax_t file_size(const path& __p, error_code& __ec) noexcept; uintmax_t hard_link_count(const path& __p); uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept; inline bool is_block_file(file_status __s) noexcept { return __s.type() == file_type::block; } inline bool is_block_file(const path& __p) { return is_block_file(status(__p)); } inline bool is_block_file(const path& __p, error_code& __ec) noexcept { return is_block_file(status(__p, __ec)); } inline bool is_character_file(file_status __s) noexcept { return __s.type() == file_type::character; } inline bool is_character_file(const path& __p) { return is_character_file(status(__p)); } inline bool is_character_file(const path& __p, error_code& __ec) noexcept { return is_character_file(status(__p, __ec)); } inline bool is_directory(file_status __s) noexcept { return __s.type() == file_type::directory; } inline bool is_directory(const path& __p) { return is_directory(status(__p)); } inline bool is_directory(const path& __p, error_code& __ec) noexcept { return is_directory(status(__p, __ec)); } bool is_empty(const path& __p); bool is_empty(const path& __p, error_code& __ec); inline bool is_fifo(file_status __s) noexcept { return __s.type() == file_type::fifo; } inline bool is_fifo(const path& __p) { return is_fifo(status(__p)); } inline bool is_fifo(const path& __p, error_code& __ec) noexcept { return is_fifo(status(__p, __ec)); } inline bool is_other(file_status __s) noexcept { return exists(__s) && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s); } inline bool is_other(const path& __p) { return is_other(status(__p)); } inline bool is_other(const path& __p, error_code& __ec) noexcept { return is_other(status(__p, __ec)); } inline bool is_regular_file(file_status __s) noexcept { return __s.type() == file_type::regular; } inline bool is_regular_file(const path& __p) { return is_regular_file(status(__p)); } inline bool is_regular_file(const path& __p, error_code& __ec) noexcept { return is_regular_file(status(__p, __ec)); } inline bool is_socket(file_status __s) noexcept { return __s.type() == file_type::socket; } inline bool is_socket(const path& __p) { return is_socket(status(__p)); } inline bool is_socket(const path& __p, error_code& __ec) noexcept { return is_socket(status(__p, __ec)); } inline bool is_symlink(file_status __s) noexcept { return __s.type() == file_type::symlink; } inline bool is_symlink(const path& __p) { return is_symlink(symlink_status(__p)); } inline bool is_symlink(const path& __p, error_code& __ec) noexcept { return is_symlink(symlink_status(__p, __ec)); } file_time_type last_write_time(const path& __p); file_time_type last_write_time(const path& __p, error_code& __ec) noexcept; void last_write_time(const path& __p, file_time_type __new_time); void last_write_time(const path& __p, file_time_type __new_time, error_code& __ec) noexcept; void permissions(const path& __p, perms __prms, perm_options __opts = perm_options::replace); inline void permissions(const path& __p, perms __prms, error_code& __ec) noexcept { permissions(__p, __prms, perm_options::replace, __ec); } void permissions(const path& __p, perms __prms, perm_options __opts, error_code& __ec) noexcept; inline path proximate(const path& __p, error_code& __ec) { return proximate(__p, current_path(), __ec); } path proximate(const path& __p, const path& __base = current_path()); path proximate(const path& __p, const path& __base, error_code& __ec); path read_symlink(const path& __p); path read_symlink(const path& __p, error_code& __ec); inline path relative(const path& __p, error_code& __ec) { return relative(__p, current_path(), __ec); } path relative(const path& __p, const path& __base = current_path()); path relative(const path& __p, const path& __base, error_code& __ec); bool remove(const path& __p); bool remove(const path& __p, error_code& __ec) noexcept; uintmax_t remove_all(const path& __p); uintmax_t remove_all(const path& __p, error_code& __ec); void rename(const path& __from, const path& __to); void rename(const path& __from, const path& __to, error_code& __ec) noexcept; void resize_file(const path& __p, uintmax_t __size); void resize_file(const path& __p, uintmax_t __size, error_code& __ec) noexcept; space_info space(const path& __p); space_info space(const path& __p, error_code& __ec) noexcept; file_status status(const path& __p); file_status status(const path& __p, error_code& __ec) noexcept; inline bool status_known(file_status __s) noexcept { return __s.type() != file_type::none; } file_status symlink_status(const path& __p); file_status symlink_status(const path& __p, error_code& __ec) noexcept; path temp_directory_path(); path temp_directory_path(error_code& __ec); path weakly_canonical(const path& __p); path weakly_canonical(const path& __p, error_code& __ec); } } # 48 "/usr/include/c++/10/filesystem" 2 3 # 97 "all-std.cxx" 2 # 1 "/usr/include/c++/10/regex" 1 3 # 32 "/usr/include/c++/10/regex" 3 # 33 "/usr/include/c++/10/regex" 3 # 53 "/usr/include/c++/10/regex" 3 # 1 "/usr/include/c++/10/cstring" 1 3 # 39 "/usr/include/c++/10/cstring" 3 # 40 "/usr/include/c++/10/cstring" 3 # 54 "/usr/include/c++/10/regex" 2 3 # 1 "/usr/include/c++/10/bits/regex_constants.h" 1 3 # 33 "/usr/include/c++/10/bits/regex_constants.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 48 "/usr/include/c++/10/bits/regex_constants.h" 3 namespace regex_constants { enum __syntax_option { _S_icase, _S_nosubs, _S_optimize, _S_collate, _S_ECMAScript, _S_basic, _S_extended, _S_awk, _S_grep, _S_egrep, _S_polynomial, _S_syntax_last }; # 81 "/usr/include/c++/10/bits/regex_constants.h" 3 enum syntax_option_type : unsigned int { }; inline constexpr syntax_option_type icase = static_cast(1 << _S_icase); inline constexpr syntax_option_type nosubs = static_cast(1 << _S_nosubs); inline constexpr syntax_option_type optimize = static_cast(1 << _S_optimize); inline constexpr syntax_option_type collate = static_cast(1 << _S_collate); # 122 "/usr/include/c++/10/bits/regex_constants.h" 3 inline constexpr syntax_option_type ECMAScript = static_cast(1 << _S_ECMAScript); # 132 "/usr/include/c++/10/bits/regex_constants.h" 3 inline constexpr syntax_option_type basic = static_cast(1 << _S_basic); inline constexpr syntax_option_type extended = static_cast(1 << _S_extended); # 152 "/usr/include/c++/10/bits/regex_constants.h" 3 inline constexpr syntax_option_type awk = static_cast(1 << _S_awk); inline constexpr syntax_option_type grep = static_cast(1 << _S_grep); inline constexpr syntax_option_type egrep = static_cast(1 << _S_egrep); inline constexpr syntax_option_type __polynomial = static_cast(1 << _S_polynomial); constexpr inline syntax_option_type operator&(syntax_option_type __a, syntax_option_type __b) { return (syntax_option_type)(static_cast(__a) & static_cast(__b)); } constexpr inline syntax_option_type operator|(syntax_option_type __a, syntax_option_type __b) { return (syntax_option_type)(static_cast(__a) | static_cast(__b)); } constexpr inline syntax_option_type operator^(syntax_option_type __a, syntax_option_type __b) { return (syntax_option_type)(static_cast(__a) ^ static_cast(__b)); } constexpr inline syntax_option_type operator~(syntax_option_type __a) { return (syntax_option_type)(~static_cast(__a)); } inline syntax_option_type& operator&=(syntax_option_type& __a, syntax_option_type __b) { return __a = __a & __b; } inline syntax_option_type& operator|=(syntax_option_type& __a, syntax_option_type __b) { return __a = __a | __b; } inline syntax_option_type& operator^=(syntax_option_type& __a, syntax_option_type __b) { return __a = __a ^ __b; } # 232 "/usr/include/c++/10/bits/regex_constants.h" 3 enum __match_flag { _S_not_bol, _S_not_eol, _S_not_bow, _S_not_eow, _S_any, _S_not_null, _S_continuous, _S_prev_avail, _S_sed, _S_no_copy, _S_first_only, _S_match_flag_last }; # 255 "/usr/include/c++/10/bits/regex_constants.h" 3 enum match_flag_type : unsigned int { }; inline constexpr match_flag_type match_default = static_cast(0); inline constexpr match_flag_type match_not_bol = static_cast(1 << _S_not_bol); inline constexpr match_flag_type match_not_eol = static_cast(1 << _S_not_eol); inline constexpr match_flag_type match_not_bow = static_cast(1 << _S_not_bow); inline constexpr match_flag_type match_not_eow = static_cast(1 << _S_not_eow); inline constexpr match_flag_type match_any = static_cast(1 << _S_any); inline constexpr match_flag_type match_not_null = static_cast(1 << _S_not_null); inline constexpr match_flag_type match_continuous = static_cast(1 << _S_continuous); inline constexpr match_flag_type match_prev_avail = static_cast(1 << _S_prev_avail); # 346 "/usr/include/c++/10/bits/regex_constants.h" 3 inline constexpr match_flag_type format_default = static_cast(0); inline constexpr match_flag_type format_sed = static_cast(1 << _S_sed); inline constexpr match_flag_type format_no_copy = static_cast(1 << _S_no_copy); inline constexpr match_flag_type format_first_only = static_cast(1 << _S_first_only); constexpr inline match_flag_type operator&(match_flag_type __a, match_flag_type __b) { return (match_flag_type)(static_cast(__a) & static_cast(__b)); } constexpr inline match_flag_type operator|(match_flag_type __a, match_flag_type __b) { return (match_flag_type)(static_cast(__a) | static_cast(__b)); } constexpr inline match_flag_type operator^(match_flag_type __a, match_flag_type __b) { return (match_flag_type)(static_cast(__a) ^ static_cast(__b)); } constexpr inline match_flag_type operator~(match_flag_type __a) { return (match_flag_type)(~static_cast(__a)); } inline match_flag_type& operator&=(match_flag_type& __a, match_flag_type __b) { return __a = __a & __b; } inline match_flag_type& operator|=(match_flag_type& __a, match_flag_type __b) { return __a = __a | __b; } inline match_flag_type& operator^=(match_flag_type& __a, match_flag_type __b) { return __a = __a ^ __b; } } } # 58 "/usr/include/c++/10/regex" 2 3 # 1 "/usr/include/c++/10/bits/regex_error.h" 1 3 # 33 "/usr/include/c++/10/bits/regex_error.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace regex_constants { enum error_type { _S_error_collate, _S_error_ctype, _S_error_escape, _S_error_backref, _S_error_brack, _S_error_paren, _S_error_brace, _S_error_badbrace, _S_error_range, _S_error_space, _S_error_badrepeat, _S_error_complexity, _S_error_stack, }; constexpr error_type error_collate(_S_error_collate); constexpr error_type error_ctype(_S_error_ctype); constexpr error_type error_escape(_S_error_escape); constexpr error_type error_backref(_S_error_backref); constexpr error_type error_brack(_S_error_brack); constexpr error_type error_paren(_S_error_paren); constexpr error_type error_brace(_S_error_brace); constexpr error_type error_badbrace(_S_error_badbrace); constexpr error_type error_range(_S_error_range); constexpr error_type error_space(_S_error_space); constexpr error_type error_badrepeat(_S_error_badrepeat); constexpr error_type error_complexity(_S_error_complexity); constexpr error_type error_stack(_S_error_stack); } # 132 "/usr/include/c++/10/bits/regex_error.h" 3 class regex_error : public std::runtime_error { regex_constants::error_type _M_code; public: explicit regex_error(regex_constants::error_type __ecode); virtual ~regex_error() throw(); regex_constants::error_type code() const { return _M_code; } private: regex_error(regex_constants::error_type __ecode, const char* __what) : std::runtime_error(__what), _M_code(__ecode) { } friend void __throw_regex_error(regex_constants::error_type, const char*); }; void __throw_regex_error(regex_constants::error_type __ecode); inline void __throw_regex_error(regex_constants::error_type __ecode, const char* __what) { (throw (regex_error(__ecode, __what))); } } # 59 "/usr/include/c++/10/regex" 2 3 # 1 "/usr/include/c++/10/bits/regex_automaton.h" 1 3 # 36 "/usr/include/c++/10/bits/regex_automaton.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { typedef long _StateIdT; static const _StateIdT _S_invalid_state_id = -1; template using _Matcher = std::function; enum _Opcode : int { _S_opcode_unknown, _S_opcode_alternative, _S_opcode_repeat, _S_opcode_backref, _S_opcode_line_begin_assertion, _S_opcode_line_end_assertion, _S_opcode_word_boundary, _S_opcode_subexpr_lookahead, _S_opcode_subexpr_begin, _S_opcode_subexpr_end, _S_opcode_dummy, _S_opcode_match, _S_opcode_accept, }; struct _State_base { protected: _Opcode _M_opcode; public: _StateIdT _M_next; union { size_t _M_subexpr; size_t _M_backref_index; struct { _StateIdT _M_alt; bool _M_neg; }; __gnu_cxx::__aligned_membuf<_Matcher> _M_matcher_storage; }; protected: explicit _State_base(_Opcode __opcode) : _M_opcode(__opcode), _M_next(_S_invalid_state_id) { } public: bool _M_has_alt() { return _M_opcode == _S_opcode_alternative || _M_opcode == _S_opcode_repeat || _M_opcode == _S_opcode_subexpr_lookahead; } # 119 "/usr/include/c++/10/bits/regex_automaton.h" 3 }; template struct _State : _State_base { typedef _Matcher<_Char_type> _MatcherT; static_assert(sizeof(_MatcherT) == sizeof(_Matcher), "std::function has the same size as " "std::function"); static_assert(alignof(_MatcherT) == alignof(_Matcher), "std::function has the same alignment as " "std::function"); explicit _State(_Opcode __opcode) : _State_base(__opcode) { if (_M_opcode() == _S_opcode_match) new (this->_M_matcher_storage._M_addr()) _MatcherT(); } _State(const _State& __rhs) : _State_base(__rhs) { if (__rhs._M_opcode() == _S_opcode_match) new (this->_M_matcher_storage._M_addr()) _MatcherT(__rhs._M_get_matcher()); } _State(_State&& __rhs) : _State_base(__rhs) { if (__rhs._M_opcode() == _S_opcode_match) new (this->_M_matcher_storage._M_addr()) _MatcherT(std::move(__rhs._M_get_matcher())); } _State& operator=(const _State&) = delete; ~_State() { if (_M_opcode() == _S_opcode_match) _M_get_matcher().~_MatcherT(); } _Opcode _M_opcode() const { return _State_base::_M_opcode; } bool _M_matches(_Char_type __char) const { return _M_get_matcher()(__char); } _MatcherT& _M_get_matcher() { return *static_cast<_MatcherT*>(this->_M_matcher_storage._M_addr()); } const _MatcherT& _M_get_matcher() const { return *static_cast( this->_M_matcher_storage._M_addr()); } }; struct _NFA_base { typedef size_t _SizeT; typedef regex_constants::syntax_option_type _FlagT; explicit _NFA_base(_FlagT __f) : _M_flags(__f), _M_start_state(0), _M_subexpr_count(0), _M_has_backref(false) { } _NFA_base(_NFA_base&&) = default; protected: ~_NFA_base() = default; public: _FlagT _M_options() const { return _M_flags; } _StateIdT _M_start() const { return _M_start_state; } _SizeT _M_sub_count() const { return _M_subexpr_count; } std::vector _M_paren_stack; _FlagT _M_flags; _StateIdT _M_start_state; _SizeT _M_subexpr_count; bool _M_has_backref; }; template struct _NFA : _NFA_base, std::vector<_State> { typedef typename _TraitsT::char_type _Char_type; typedef _State<_Char_type> _StateT; typedef _Matcher<_Char_type> _MatcherT; _NFA(const typename _TraitsT::locale_type& __loc, _FlagT __flags) : _NFA_base(__flags) { _M_traits.imbue(__loc); } _NFA(const _NFA&) = delete; _NFA(_NFA&&) = default; _StateIdT _M_insert_accept() { auto __ret = _M_insert_state(_StateT(_S_opcode_accept)); return __ret; } _StateIdT _M_insert_alt(_StateIdT __next, _StateIdT __alt, bool __neg __attribute__((__unused__))) { _StateT __tmp(_S_opcode_alternative); __tmp._M_next = __next; __tmp._M_alt = __alt; return _M_insert_state(std::move(__tmp)); } _StateIdT _M_insert_repeat(_StateIdT __next, _StateIdT __alt, bool __neg) { _StateT __tmp(_S_opcode_repeat); __tmp._M_next = __next; __tmp._M_alt = __alt; __tmp._M_neg = __neg; return _M_insert_state(std::move(__tmp)); } _StateIdT _M_insert_matcher(_MatcherT __m) { _StateT __tmp(_S_opcode_match); __tmp._M_get_matcher() = std::move(__m); return _M_insert_state(std::move(__tmp)); } _StateIdT _M_insert_subexpr_begin() { auto __id = this->_M_subexpr_count++; this->_M_paren_stack.push_back(__id); _StateT __tmp(_S_opcode_subexpr_begin); __tmp._M_subexpr = __id; return _M_insert_state(std::move(__tmp)); } _StateIdT _M_insert_subexpr_end() { _StateT __tmp(_S_opcode_subexpr_end); __tmp._M_subexpr = this->_M_paren_stack.back(); this->_M_paren_stack.pop_back(); return _M_insert_state(std::move(__tmp)); } _StateIdT _M_insert_backref(size_t __index); _StateIdT _M_insert_line_begin() { return _M_insert_state(_StateT(_S_opcode_line_begin_assertion)); } _StateIdT _M_insert_line_end() { return _M_insert_state(_StateT(_S_opcode_line_end_assertion)); } _StateIdT _M_insert_word_bound(bool __neg) { _StateT __tmp(_S_opcode_word_boundary); __tmp._M_neg = __neg; return _M_insert_state(std::move(__tmp)); } _StateIdT _M_insert_lookahead(_StateIdT __alt, bool __neg) { _StateT __tmp(_S_opcode_subexpr_lookahead); __tmp._M_alt = __alt; __tmp._M_neg = __neg; return _M_insert_state(std::move(__tmp)); } _StateIdT _M_insert_dummy() { return _M_insert_state(_StateT(_S_opcode_dummy)); } _StateIdT _M_insert_state(_StateT __s) { this->push_back(std::move(__s)); if (this->size() > 100000) __throw_regex_error( regex_constants::error_space, "Number of NFA states exceeds limit. Please use shorter regex " "string, or use smaller brace expression, or make " "_GLIBCXX_REGEX_STATE_LIMIT larger."); return this->size() - 1; } void _M_eliminate_dummy(); public: _TraitsT _M_traits; }; template class _StateSeq { public: typedef _NFA<_TraitsT> _RegexT; public: _StateSeq(_RegexT& __nfa, _StateIdT __s) : _M_nfa(__nfa), _M_start(__s), _M_end(__s) { } _StateSeq(_RegexT& __nfa, _StateIdT __s, _StateIdT __end) : _M_nfa(__nfa), _M_start(__s), _M_end(__end) { } void _M_append(_StateIdT __id) { _M_nfa[_M_end]._M_next = __id; _M_end = __id; } void _M_append(const _StateSeq& __s) { _M_nfa[_M_end]._M_next = __s._M_start; _M_end = __s._M_end; } _StateSeq _M_clone(); public: _RegexT& _M_nfa; _StateIdT _M_start; _StateIdT _M_end; }; } } # 1 "/usr/include/c++/10/bits/regex_automaton.tcc" 1 3 # 31 "/usr/include/c++/10/bits/regex_automaton.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { # 147 "/usr/include/c++/10/bits/regex_automaton.tcc" 3 template _StateIdT _NFA<_TraitsT>::_M_insert_backref(size_t __index) { if (this->_M_flags & regex_constants::__polynomial) __throw_regex_error(regex_constants::error_complexity, "Unexpected back-reference in polynomial mode."); if (__index >= _M_subexpr_count) __throw_regex_error( regex_constants::error_backref, "Back-reference index exceeds current sub-expression count."); for (auto __it : this->_M_paren_stack) if (__index == __it) __throw_regex_error( regex_constants::error_backref, "Back-reference referred to an opened sub-expression."); this->_M_has_backref = true; _StateT __tmp(_S_opcode_backref); __tmp._M_backref_index = __index; return _M_insert_state(std::move(__tmp)); } template void _NFA<_TraitsT>::_M_eliminate_dummy() { for (auto& __it : *this) { while (__it._M_next >= 0 && (*this)[__it._M_next]._M_opcode() == _S_opcode_dummy) __it._M_next = (*this)[__it._M_next]._M_next; if (__it._M_has_alt()) while (__it._M_alt >= 0 && (*this)[__it._M_alt]._M_opcode() == _S_opcode_dummy) __it._M_alt = (*this)[__it._M_alt]._M_next; } } template _StateSeq<_TraitsT> _StateSeq<_TraitsT>::_M_clone() { std::map<_StateIdT, _StateIdT> __m; std::stack<_StateIdT> __stack; __stack.push(_M_start); while (!__stack.empty()) { auto __u = __stack.top(); __stack.pop(); auto __dup = _M_nfa[__u]; auto __id = _M_nfa._M_insert_state(std::move(__dup)); __m[__u] = __id; if (__dup._M_has_alt()) if (__dup._M_alt != _S_invalid_state_id && __m.count(__dup._M_alt) == 0) __stack.push(__dup._M_alt); if (__u == _M_end) continue; if (__dup._M_next != _S_invalid_state_id && __m.count(__dup._M_next) == 0) __stack.push(__dup._M_next); } for (auto __it : __m) { auto __v = __it.second; auto& __ref = _M_nfa[__v]; if (__ref._M_next != _S_invalid_state_id) __ref._M_next = __m.find(__ref._M_next)->second; if (__ref._M_has_alt() && __ref._M_alt != _S_invalid_state_id) __ref._M_alt = __m.find(__ref._M_alt)->second; } return _StateSeq(_M_nfa, __m[_M_start], __m[_M_end]); } } } # 402 "/usr/include/c++/10/bits/regex_automaton.h" 2 3 # 60 "/usr/include/c++/10/regex" 2 3 # 1 "/usr/include/c++/10/bits/regex_scanner.h" 1 3 # 31 "/usr/include/c++/10/bits/regex_scanner.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { struct _ScannerBase { public: enum _TokenT : unsigned { _S_token_anychar, _S_token_ord_char, _S_token_oct_num, _S_token_hex_num, _S_token_backref, _S_token_subexpr_begin, _S_token_subexpr_no_group_begin, _S_token_subexpr_lookahead_begin, _S_token_subexpr_end, _S_token_bracket_begin, _S_token_bracket_neg_begin, _S_token_bracket_end, _S_token_interval_begin, _S_token_interval_end, _S_token_quoted_class, _S_token_char_class_name, _S_token_collsymbol, _S_token_equiv_class_name, _S_token_opt, _S_token_or, _S_token_closure0, _S_token_closure1, _S_token_line_begin, _S_token_line_end, _S_token_word_bound, _S_token_comma, _S_token_dup_count, _S_token_eof, _S_token_bracket_dash, _S_token_unknown = -1u }; protected: typedef regex_constants::syntax_option_type _FlagT; enum _StateT { _S_state_normal, _S_state_in_brace, _S_state_in_bracket, }; protected: _ScannerBase(_FlagT __flags) : _M_state(_S_state_normal), _M_flags(__flags), _M_escape_tbl(_M_is_ecma() ? _M_ecma_escape_tbl : _M_awk_escape_tbl), _M_spec_char(_M_is_ecma() ? _M_ecma_spec_char : _M_flags & regex_constants::basic ? _M_basic_spec_char : _M_flags & regex_constants::extended ? _M_extended_spec_char : _M_flags & regex_constants::grep ? ".[\\*^$\n" : _M_flags & regex_constants::egrep ? ".[\\()*+?{|^$\n" : _M_flags & regex_constants::awk ? _M_extended_spec_char : nullptr), _M_at_bracket_start(false) { ; } protected: const char* _M_find_escape(char __c) { auto __it = _M_escape_tbl; for (; __it->first != '\0'; ++__it) if (__it->first == __c) return &__it->second; return nullptr; } bool _M_is_ecma() const { return _M_flags & regex_constants::ECMAScript; } bool _M_is_basic() const { return _M_flags & (regex_constants::basic | regex_constants::grep); } bool _M_is_extended() const { return _M_flags & (regex_constants::extended | regex_constants::egrep | regex_constants::awk); } bool _M_is_grep() const { return _M_flags & (regex_constants::grep | regex_constants::egrep); } bool _M_is_awk() const { return _M_flags & regex_constants::awk; } protected: const std::pair _M_token_tbl[9] = { {'^', _S_token_line_begin}, {'$', _S_token_line_end}, {'.', _S_token_anychar}, {'*', _S_token_closure0}, {'+', _S_token_closure1}, {'?', _S_token_opt}, {'|', _S_token_or}, {'\n', _S_token_or}, {'\0', _S_token_or}, }; const std::pair _M_ecma_escape_tbl[8] = { {'0', '\0'}, {'b', '\b'}, {'f', '\f'}, {'n', '\n'}, {'r', '\r'}, {'t', '\t'}, {'v', '\v'}, {'\0', '\0'}, }; const std::pair _M_awk_escape_tbl[11] = { {'"', '"'}, {'/', '/'}, {'\\', '\\'}, {'a', '\a'}, {'b', '\b'}, {'f', '\f'}, {'n', '\n'}, {'r', '\r'}, {'t', '\t'}, {'v', '\v'}, {'\0', '\0'}, }; const char* _M_ecma_spec_char = "^$\\.*+?()[]{}|"; const char* _M_basic_spec_char = ".[\\*^$"; const char* _M_extended_spec_char = ".[\\()*+?{|^$"; _StateT _M_state; _FlagT _M_flags; _TokenT _M_token; const std::pair* _M_escape_tbl; const char* _M_spec_char; bool _M_at_bracket_start; }; # 209 "/usr/include/c++/10/bits/regex_scanner.h" 3 template class _Scanner : public _ScannerBase { public: typedef const _CharT* _IterT; typedef std::basic_string<_CharT> _StringT; typedef regex_constants::syntax_option_type _FlagT; typedef const std::ctype<_CharT> _CtypeT; _Scanner(_IterT __begin, _IterT __end, _FlagT __flags, std::locale __loc); void _M_advance(); _TokenT _M_get_token() const { return _M_token; } const _StringT& _M_get_value() const { return _M_value; } private: void _M_scan_normal(); void _M_scan_in_bracket(); void _M_scan_in_brace(); void _M_eat_escape_ecma(); void _M_eat_escape_posix(); void _M_eat_escape_awk(); void _M_eat_class(char); _IterT _M_current; _IterT _M_end; _CtypeT& _M_ctype; _StringT _M_value; void (_Scanner::* _M_eat_escape)(); }; } } # 1 "/usr/include/c++/10/bits/regex_scanner.tcc" 1 3 # 49 "/usr/include/c++/10/bits/regex_scanner.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template _Scanner<_CharT>:: _Scanner(typename _Scanner::_IterT __begin, typename _Scanner::_IterT __end, _FlagT __flags, std::locale __loc) : _ScannerBase(__flags), _M_current(__begin), _M_end(__end), _M_ctype(std::use_facet<_CtypeT>(__loc)), _M_eat_escape(_M_is_ecma() ? &_Scanner::_M_eat_escape_ecma : &_Scanner::_M_eat_escape_posix) { _M_advance(); } template void _Scanner<_CharT>:: _M_advance() { if (_M_current == _M_end) { _M_token = _S_token_eof; return; } if (_M_state == _S_state_normal) _M_scan_normal(); else if (_M_state == _S_state_in_bracket) _M_scan_in_bracket(); else if (_M_state == _S_state_in_brace) _M_scan_in_brace(); else { ; } } template void _Scanner<_CharT>:: _M_scan_normal() { auto __c = *_M_current++; if (std::strchr(_M_spec_char, _M_ctype.narrow(__c, ' ')) == nullptr) { _M_token = _S_token_ord_char; _M_value.assign(1, __c); return; } if (__c == '\\') { if (_M_current == _M_end) __throw_regex_error( regex_constants::error_escape, "Unexpected end of regex when escaping."); if (!_M_is_basic() || (*_M_current != '(' && *_M_current != ')' && *_M_current != '{')) { (this->*_M_eat_escape)(); return; } __c = *_M_current++; } if (__c == '(') { if (_M_is_ecma() && *_M_current == '?') { if (++_M_current == _M_end) __throw_regex_error( regex_constants::error_paren, "Unexpected end of regex when in an open parenthesis."); if (*_M_current == ':') { ++_M_current; _M_token = _S_token_subexpr_no_group_begin; } else if (*_M_current == '=') { ++_M_current; _M_token = _S_token_subexpr_lookahead_begin; _M_value.assign(1, 'p'); } else if (*_M_current == '!') { ++_M_current; _M_token = _S_token_subexpr_lookahead_begin; _M_value.assign(1, 'n'); } else __throw_regex_error( regex_constants::error_paren, "Invalid special open parenthesis."); } else if (_M_flags & regex_constants::nosubs) _M_token = _S_token_subexpr_no_group_begin; else _M_token = _S_token_subexpr_begin; } else if (__c == ')') _M_token = _S_token_subexpr_end; else if (__c == '[') { _M_state = _S_state_in_bracket; _M_at_bracket_start = true; if (_M_current != _M_end && *_M_current == '^') { _M_token = _S_token_bracket_neg_begin; ++_M_current; } else _M_token = _S_token_bracket_begin; } else if (__c == '{') { _M_state = _S_state_in_brace; _M_token = _S_token_interval_begin; } else if (__c != ']' && __c != '}') { auto __it = _M_token_tbl; auto __narrowc = _M_ctype.narrow(__c, '\0'); for (; __it->first != '\0'; ++__it) if (__it->first == __narrowc) { _M_token = __it->second; return; } ; } else { _M_token = _S_token_ord_char; _M_value.assign(1, __c); } } template void _Scanner<_CharT>:: _M_scan_in_bracket() { if (_M_current == _M_end) __throw_regex_error( regex_constants::error_brack, "Unexpected end of regex when in bracket expression."); auto __c = *_M_current++; if (__c == '-') _M_token = _S_token_bracket_dash; else if (__c == '[') { if (_M_current == _M_end) __throw_regex_error(regex_constants::error_brack, "Unexpected character class open bracket."); if (*_M_current == '.') { _M_token = _S_token_collsymbol; _M_eat_class(*_M_current++); } else if (*_M_current == ':') { _M_token = _S_token_char_class_name; _M_eat_class(*_M_current++); } else if (*_M_current == '=') { _M_token = _S_token_equiv_class_name; _M_eat_class(*_M_current++); } else { _M_token = _S_token_ord_char; _M_value.assign(1, __c); } } else if (__c == ']' && (_M_is_ecma() || !_M_at_bracket_start)) { _M_token = _S_token_bracket_end; _M_state = _S_state_normal; } else if (__c == '\\' && (_M_is_ecma() || _M_is_awk())) (this->*_M_eat_escape)(); else { _M_token = _S_token_ord_char; _M_value.assign(1, __c); } _M_at_bracket_start = false; } template void _Scanner<_CharT>:: _M_scan_in_brace() { if (_M_current == _M_end) __throw_regex_error( regex_constants::error_brace, "Unexpected end of regex when in brace expression."); auto __c = *_M_current++; if (_M_ctype.is(_CtypeT::digit, __c)) { _M_token = _S_token_dup_count; _M_value.assign(1, __c); while (_M_current != _M_end && _M_ctype.is(_CtypeT::digit, *_M_current)) _M_value += *_M_current++; } else if (__c == ',') _M_token = _S_token_comma; else if (_M_is_basic()) { if (__c == '\\' && _M_current != _M_end && *_M_current == '}') { _M_state = _S_state_normal; _M_token = _S_token_interval_end; ++_M_current; } else __throw_regex_error(regex_constants::error_badbrace, "Unexpected character in brace expression."); } else if (__c == '}') { _M_state = _S_state_normal; _M_token = _S_token_interval_end; } else __throw_regex_error(regex_constants::error_badbrace, "Unexpected character in brace expression."); } template void _Scanner<_CharT>:: _M_eat_escape_ecma() { if (_M_current == _M_end) __throw_regex_error(regex_constants::error_escape, "Unexpected end of regex when escaping."); auto __c = *_M_current++; auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0')); if (__pos != nullptr && (__c != 'b' || _M_state == _S_state_in_bracket)) { _M_token = _S_token_ord_char; _M_value.assign(1, *__pos); } else if (__c == 'b') { _M_token = _S_token_word_bound; _M_value.assign(1, 'p'); } else if (__c == 'B') { _M_token = _S_token_word_bound; _M_value.assign(1, 'n'); } else if (__c == 'd' || __c == 'D' || __c == 's' || __c == 'S' || __c == 'w' || __c == 'W') { _M_token = _S_token_quoted_class; _M_value.assign(1, __c); } else if (__c == 'c') { if (_M_current == _M_end) __throw_regex_error( regex_constants::error_escape, "Unexpected end of regex when reading control code."); _M_token = _S_token_ord_char; _M_value.assign(1, *_M_current++); } else if (__c == 'x' || __c == 'u') { _M_value.erase(); for (int __i = 0; __i < (__c == 'x' ? 2 : 4); __i++) { if (_M_current == _M_end || !_M_ctype.is(_CtypeT::xdigit, *_M_current)) __throw_regex_error( regex_constants::error_escape, "Unexpected end of regex when ascii character."); _M_value += *_M_current++; } _M_token = _S_token_hex_num; } else if (_M_ctype.is(_CtypeT::digit, __c)) { _M_value.assign(1, __c); while (_M_current != _M_end && _M_ctype.is(_CtypeT::digit, *_M_current)) _M_value += *_M_current++; _M_token = _S_token_backref; } else { _M_token = _S_token_ord_char; _M_value.assign(1, __c); } } template void _Scanner<_CharT>:: _M_eat_escape_posix() { if (_M_current == _M_end) __throw_regex_error(regex_constants::error_escape, "Unexpected end of regex when escaping."); auto __c = *_M_current; auto __pos = std::strchr(_M_spec_char, _M_ctype.narrow(__c, '\0')); if (__pos != nullptr && *__pos != '\0') { _M_token = _S_token_ord_char; _M_value.assign(1, __c); } else if (_M_is_awk()) { _M_eat_escape_awk(); return; } else if (_M_is_basic() && _M_ctype.is(_CtypeT::digit, __c) && __c != '0') { _M_token = _S_token_backref; _M_value.assign(1, __c); } else { __throw_regex_error(regex_constants::error_escape, "Unexpected escape character."); } ++_M_current; } template void _Scanner<_CharT>:: _M_eat_escape_awk() { auto __c = *_M_current++; auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0')); if (__pos != nullptr) { _M_token = _S_token_ord_char; _M_value.assign(1, *__pos); } else if (_M_ctype.is(_CtypeT::digit, __c) && __c != '8' && __c != '9') { _M_value.assign(1, __c); for (int __i = 0; __i < 2 && _M_current != _M_end && _M_ctype.is(_CtypeT::digit, *_M_current) && *_M_current != '8' && *_M_current != '9'; __i++) _M_value += *_M_current++; _M_token = _S_token_oct_num; return; } else __throw_regex_error(regex_constants::error_escape, "Unexpected escape character."); } template void _Scanner<_CharT>:: _M_eat_class(char __ch) { for (_M_value.clear(); _M_current != _M_end && *_M_current != __ch;) _M_value += *_M_current++; if (_M_current == _M_end || *_M_current++ != __ch || _M_current == _M_end || *_M_current++ != ']') { if (__ch == ':') __throw_regex_error(regex_constants::error_ctype, "Unexpected end of character class."); else __throw_regex_error(regex_constants::error_collate, "Unexpected end of character class."); } } # 587 "/usr/include/c++/10/bits/regex_scanner.tcc" 3 } } # 273 "/usr/include/c++/10/bits/regex_scanner.h" 2 3 # 61 "/usr/include/c++/10/regex" 2 3 # 1 "/usr/include/c++/10/bits/regex_compiler.h" 1 3 # 31 "/usr/include/c++/10/bits/regex_compiler.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { template class regex_traits; } namespace __detail { template struct _BracketMatcher; template class _Compiler { public: typedef typename _TraitsT::char_type _CharT; typedef const _CharT* _IterT; typedef _NFA<_TraitsT> _RegexT; typedef regex_constants::syntax_option_type _FlagT; _Compiler(_IterT __b, _IterT __e, const typename _TraitsT::locale_type& __traits, _FlagT __flags); shared_ptr _M_get_nfa() { return std::move(_M_nfa); } private: typedef _Scanner<_CharT> _ScannerT; typedef typename _TraitsT::string_type _StringT; typedef typename _ScannerT::_TokenT _TokenT; typedef _StateSeq<_TraitsT> _StateSeqT; typedef std::stack<_StateSeqT> _StackT; typedef std::ctype<_CharT> _CtypeT; bool _M_match_token(_TokenT __token); void _M_disjunction(); void _M_alternative(); bool _M_term(); bool _M_assertion(); bool _M_quantifier(); bool _M_atom(); bool _M_bracket_expression(); template void _M_insert_any_matcher_ecma(); template void _M_insert_any_matcher_posix(); template void _M_insert_char_matcher(); template void _M_insert_character_class_matcher(); template void _M_insert_bracket_matcher(bool __neg); template bool _M_expression_term(pair& __last_char, _BracketMatcher<_TraitsT, __icase, __collate>& __matcher); int _M_cur_int_value(int __radix); bool _M_try_char(); _StateSeqT _M_pop() { auto ret = _M_stack.top(); _M_stack.pop(); return ret; } _FlagT _M_flags; _ScannerT _M_scanner; shared_ptr<_RegexT> _M_nfa; _StringT _M_value; _StackT _M_stack; const _TraitsT& _M_traits; const _CtypeT& _M_ctype; }; template struct __is_contiguous_iter : is_pointer<_Tp>::type { }; template struct __is_contiguous_iter<__gnu_cxx::__normal_iterator<_Tp*, _Cont>> : true_type { }; template using __enable_if_contiguous_iter = __enable_if_t< __is_contiguous_iter<_Iter>::value, std::shared_ptr> >; template using __disable_if_contiguous_iter = __enable_if_t< !__is_contiguous_iter<_Iter>::value, std::shared_ptr> >; template inline __enable_if_contiguous_iter<_FwdIter, _TraitsT> __compile_nfa(_FwdIter __first, _FwdIter __last, const typename _TraitsT::locale_type& __loc, regex_constants::syntax_option_type __flags) { size_t __len = __last - __first; const auto* __cfirst = __len ? std::__addressof(*__first) : nullptr; using _Cmplr = _Compiler<_TraitsT>; return _Cmplr(__cfirst, __cfirst + __len, __loc, __flags)._M_get_nfa(); } template inline __disable_if_contiguous_iter<_FwdIter, _TraitsT> __compile_nfa(_FwdIter __first, _FwdIter __last, const typename _TraitsT::locale_type& __loc, regex_constants::syntax_option_type __flags) { const basic_string __str(__first, __last); return __compile_nfa<_TraitsT>(__str.data(), __str.data() + __str.size(), __loc, __flags); } template class _RegexTranslatorBase { public: typedef typename _TraitsT::char_type _CharT; typedef typename _TraitsT::string_type _StringT; typedef _StringT _StrTransT; explicit _RegexTranslatorBase(const _TraitsT& __traits) : _M_traits(__traits) { } _CharT _M_translate(_CharT __ch) const { if (__icase) return _M_traits.translate_nocase(__ch); else if (__collate) return _M_traits.translate(__ch); else return __ch; } _StrTransT _M_transform(_CharT __ch) const { _StrTransT __str(1, __ch); return _M_traits.transform(__str.begin(), __str.end()); } bool _M_match_range(const _StrTransT& __first, const _StrTransT& __last, const _StrTransT& __s) const { return __first <= __s && __s <= __last; } protected: bool _M_in_range_icase(_CharT __first, _CharT __last, _CharT __ch) const { typedef std::ctype<_CharT> __ctype_type; const auto& __fctyp = use_facet<__ctype_type>(this->_M_traits.getloc()); auto __lower = __fctyp.tolower(__ch); auto __upper = __fctyp.toupper(__ch); return (__first <= __lower && __lower <= __last) || (__first <= __upper && __upper <= __last); } const _TraitsT& _M_traits; }; template class _RegexTranslator : public _RegexTranslatorBase<_TraitsT, __icase, __collate> { public: typedef _RegexTranslatorBase<_TraitsT, __icase, __collate> _Base; using _Base::_Base; }; template class _RegexTranslator<_TraitsT, __icase, false> : public _RegexTranslatorBase<_TraitsT, __icase, false> { public: typedef _RegexTranslatorBase<_TraitsT, __icase, false> _Base; typedef typename _Base::_CharT _CharT; typedef _CharT _StrTransT; using _Base::_Base; _StrTransT _M_transform(_CharT __ch) const { return __ch; } bool _M_match_range(_CharT __first, _CharT __last, _CharT __ch) const { if (!__icase) return __first <= __ch && __ch <= __last; return this->_M_in_range_icase(__first, __last, __ch); } }; template class _RegexTranslator, true, true> : public _RegexTranslatorBase, true, true> { public: typedef _RegexTranslatorBase, true, true> _Base; typedef typename _Base::_CharT _CharT; typedef typename _Base::_StrTransT _StrTransT; using _Base::_Base; bool _M_match_range(const _StrTransT& __first, const _StrTransT& __last, const _StrTransT& __str) const { ; ; ; return this->_M_in_range_icase(__first[0], __last[0], __str[0]); } }; template class _RegexTranslator<_TraitsT, false, false> { public: typedef typename _TraitsT::char_type _CharT; typedef _CharT _StrTransT; explicit _RegexTranslator(const _TraitsT&) { } _CharT _M_translate(_CharT __ch) const { return __ch; } _StrTransT _M_transform(_CharT __ch) const { return __ch; } bool _M_match_range(_CharT __first, _CharT __last, _CharT __ch) const { return __first <= __ch && __ch <= __last; } }; template struct _AnyMatcher; template struct _AnyMatcher<_TraitsT, false, __icase, __collate> { typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; typedef typename _TransT::_CharT _CharT; explicit _AnyMatcher(const _TraitsT& __traits) : _M_translator(__traits) { } bool operator()(_CharT __ch) const { static auto __nul = _M_translator._M_translate('\0'); return _M_translator._M_translate(__ch) != __nul; } _TransT _M_translator; }; template struct _AnyMatcher<_TraitsT, true, __icase, __collate> { typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; typedef typename _TransT::_CharT _CharT; explicit _AnyMatcher(const _TraitsT& __traits) : _M_translator(__traits) { } bool operator()(_CharT __ch) const { return _M_apply(__ch, typename is_same<_CharT, char>::type()); } bool _M_apply(_CharT __ch, true_type) const { auto __c = _M_translator._M_translate(__ch); auto __n = _M_translator._M_translate('\n'); auto __r = _M_translator._M_translate('\r'); return __c != __n && __c != __r; } bool _M_apply(_CharT __ch, false_type) const { auto __c = _M_translator._M_translate(__ch); auto __n = _M_translator._M_translate('\n'); auto __r = _M_translator._M_translate('\r'); auto __u2028 = _M_translator._M_translate(u'\u2028'); auto __u2029 = _M_translator._M_translate(u'\u2029'); return __c != __n && __c != __r && __c != __u2028 && __c != __u2029; } _TransT _M_translator; }; template struct _CharMatcher { typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; typedef typename _TransT::_CharT _CharT; _CharMatcher(_CharT __ch, const _TraitsT& __traits) : _M_translator(__traits), _M_ch(_M_translator._M_translate(__ch)) { } bool operator()(_CharT __ch) const { return _M_ch == _M_translator._M_translate(__ch); } _TransT _M_translator; _CharT _M_ch; }; template struct _BracketMatcher { public: typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; typedef typename _TransT::_CharT _CharT; typedef typename _TransT::_StrTransT _StrTransT; typedef typename _TraitsT::string_type _StringT; typedef typename _TraitsT::char_class_type _CharClassT; public: _BracketMatcher(bool __is_non_matching, const _TraitsT& __traits) : _M_class_set(0), _M_translator(__traits), _M_traits(__traits), _M_is_non_matching(__is_non_matching) { } bool operator()(_CharT __ch) const { ; return _M_apply(__ch, _UseCache()); } void _M_add_char(_CharT __c) { _M_char_set.push_back(_M_translator._M_translate(__c)); ; } _StringT _M_add_collate_element(const _StringT& __s) { auto __st = _M_traits.lookup_collatename(__s.data(), __s.data() + __s.size()); if (__st.empty()) __throw_regex_error(regex_constants::error_collate, "Invalid collate element."); _M_char_set.push_back(_M_translator._M_translate(__st[0])); ; return __st; } void _M_add_equivalence_class(const _StringT& __s) { auto __st = _M_traits.lookup_collatename(__s.data(), __s.data() + __s.size()); if (__st.empty()) __throw_regex_error(regex_constants::error_collate, "Invalid equivalence class."); __st = _M_traits.transform_primary(__st.data(), __st.data() + __st.size()); _M_equiv_set.push_back(__st); ; } void _M_add_character_class(const _StringT& __s, bool __neg) { auto __mask = _M_traits.lookup_classname(__s.data(), __s.data() + __s.size(), __icase); if (__mask == 0) __throw_regex_error(regex_constants::error_collate, "Invalid character class."); if (!__neg) _M_class_set |= __mask; else _M_neg_class_set.push_back(__mask); ; } void _M_make_range(_CharT __l, _CharT __r) { if (__l > __r) __throw_regex_error(regex_constants::error_range, "Invalid range in bracket expression."); _M_range_set.push_back(make_pair(_M_translator._M_transform(__l), _M_translator._M_transform(__r))); ; } void _M_ready() { std::sort(_M_char_set.begin(), _M_char_set.end()); auto __end = std::unique(_M_char_set.begin(), _M_char_set.end()); _M_char_set.erase(__end, _M_char_set.end()); _M_make_cache(_UseCache()); ; } private: typedef typename std::is_same<_CharT, char>::type _UseCache; static constexpr size_t _S_cache_size = 1ul << (sizeof(_CharT) * 8 * int(_UseCache::value)); struct _Dummy { }; typedef typename std::conditional<_UseCache::value, std::bitset<_S_cache_size>, _Dummy>::type _CacheT; typedef typename std::make_unsigned<_CharT>::type _UnsignedCharT; bool _M_apply(_CharT __ch, false_type) const; bool _M_apply(_CharT __ch, true_type) const { return _M_cache[static_cast<_UnsignedCharT>(__ch)]; } void _M_make_cache(true_type) { for (unsigned __i = 0; __i < _M_cache.size(); __i++) _M_cache[__i] = _M_apply(static_cast<_CharT>(__i), false_type()); } void _M_make_cache(false_type) { } private: std::vector<_CharT> _M_char_set; std::vector<_StringT> _M_equiv_set; std::vector> _M_range_set; std::vector<_CharClassT> _M_neg_class_set; _CharClassT _M_class_set; _TransT _M_translator; const _TraitsT& _M_traits; bool _M_is_non_matching; _CacheT _M_cache; }; } } # 1 "/usr/include/c++/10/bits/regex_compiler.tcc" 1 3 # 58 "/usr/include/c++/10/bits/regex_compiler.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template _Compiler<_TraitsT>:: _Compiler(_IterT __b, _IterT __e, const typename _TraitsT::locale_type& __loc, _FlagT __flags) : _M_flags((__flags & (regex_constants::ECMAScript | regex_constants::basic | regex_constants::extended | regex_constants::grep | regex_constants::egrep | regex_constants::awk)) ? __flags : __flags | regex_constants::ECMAScript), _M_scanner(__b, __e, _M_flags, __loc), _M_nfa(make_shared<_RegexT>(__loc, _M_flags)), _M_traits(_M_nfa->_M_traits), _M_ctype(std::use_facet<_CtypeT>(__loc)) { _StateSeqT __r(*_M_nfa, _M_nfa->_M_start()); __r._M_append(_M_nfa->_M_insert_subexpr_begin()); this->_M_disjunction(); if (!_M_match_token(_ScannerT::_S_token_eof)) __throw_regex_error(regex_constants::error_paren); __r._M_append(_M_pop()); ; __r._M_append(_M_nfa->_M_insert_subexpr_end()); __r._M_append(_M_nfa->_M_insert_accept()); _M_nfa->_M_eliminate_dummy(); } template void _Compiler<_TraitsT>:: _M_disjunction() { this->_M_alternative(); while (_M_match_token(_ScannerT::_S_token_or)) { _StateSeqT __alt1 = _M_pop(); this->_M_alternative(); _StateSeqT __alt2 = _M_pop(); auto __end = _M_nfa->_M_insert_dummy(); __alt1._M_append(__end); __alt2._M_append(__end); _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_alt( __alt2._M_start, __alt1._M_start, false), __end)); } } template void _Compiler<_TraitsT>:: _M_alternative() { if (this->_M_term()) { _StateSeqT __re = _M_pop(); this->_M_alternative(); __re._M_append(_M_pop()); _M_stack.push(__re); } else _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_dummy())); } template bool _Compiler<_TraitsT>:: _M_term() { if (this->_M_assertion()) return true; if (this->_M_atom()) { while (this->_M_quantifier()); return true; } return false; } template bool _Compiler<_TraitsT>:: _M_assertion() { if (_M_match_token(_ScannerT::_S_token_line_begin)) _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_line_begin())); else if (_M_match_token(_ScannerT::_S_token_line_end)) _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_line_end())); else if (_M_match_token(_ScannerT::_S_token_word_bound)) _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa-> _M_insert_word_bound(_M_value[0] == 'n'))); else if (_M_match_token(_ScannerT::_S_token_subexpr_lookahead_begin)) { auto __neg = _M_value[0] == 'n'; this->_M_disjunction(); if (!_M_match_token(_ScannerT::_S_token_subexpr_end)) __throw_regex_error(regex_constants::error_paren, "Parenthesis is not closed."); auto __tmp = _M_pop(); __tmp._M_append(_M_nfa->_M_insert_accept()); _M_stack.push( _StateSeqT( *_M_nfa, _M_nfa->_M_insert_lookahead(__tmp._M_start, __neg))); } else return false; return true; } template bool _Compiler<_TraitsT>:: _M_quantifier() { bool __neg = (_M_flags & regex_constants::ECMAScript); auto __init = [this, &__neg]() { if (_M_stack.empty()) __throw_regex_error(regex_constants::error_badrepeat, "Nothing to repeat before a quantifier."); __neg = __neg && _M_match_token(_ScannerT::_S_token_opt); }; if (_M_match_token(_ScannerT::_S_token_closure0)) { __init(); auto __e = _M_pop(); _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_repeat(_S_invalid_state_id, __e._M_start, __neg)); __e._M_append(__r); _M_stack.push(__r); } else if (_M_match_token(_ScannerT::_S_token_closure1)) { __init(); auto __e = _M_pop(); __e._M_append(_M_nfa->_M_insert_repeat(_S_invalid_state_id, __e._M_start, __neg)); _M_stack.push(__e); } else if (_M_match_token(_ScannerT::_S_token_opt)) { __init(); auto __e = _M_pop(); auto __end = _M_nfa->_M_insert_dummy(); _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_repeat(_S_invalid_state_id, __e._M_start, __neg)); __e._M_append(__end); __r._M_append(__end); _M_stack.push(__r); } else if (_M_match_token(_ScannerT::_S_token_interval_begin)) { if (_M_stack.empty()) __throw_regex_error(regex_constants::error_badrepeat, "Nothing to repeat before a quantifier."); if (!_M_match_token(_ScannerT::_S_token_dup_count)) __throw_regex_error(regex_constants::error_badbrace, "Unexpected token in brace expression."); _StateSeqT __r(_M_pop()); _StateSeqT __e(*_M_nfa, _M_nfa->_M_insert_dummy()); long __min_rep = _M_cur_int_value(10); bool __infi = false; long __n; if (_M_match_token(_ScannerT::_S_token_comma)) if (_M_match_token(_ScannerT::_S_token_dup_count)) __n = _M_cur_int_value(10) - __min_rep; else __infi = true; else __n = 0; if (!_M_match_token(_ScannerT::_S_token_interval_end)) __throw_regex_error(regex_constants::error_brace, "Unexpected end of brace expression."); __neg = __neg && _M_match_token(_ScannerT::_S_token_opt); for (long __i = 0; __i < __min_rep; ++__i) __e._M_append(__r._M_clone()); if (__infi) { auto __tmp = __r._M_clone(); _StateSeqT __s(*_M_nfa, _M_nfa->_M_insert_repeat(_S_invalid_state_id, __tmp._M_start, __neg)); __tmp._M_append(__s); __e._M_append(__s); } else { if (__n < 0) __throw_regex_error(regex_constants::error_badbrace, "Invalid range in brace expression."); auto __end = _M_nfa->_M_insert_dummy(); std::stack<_StateIdT> __stack; for (long __i = 0; __i < __n; ++__i) { auto __tmp = __r._M_clone(); auto __alt = _M_nfa->_M_insert_repeat(__tmp._M_start, __end, __neg); __stack.push(__alt); __e._M_append(_StateSeqT(*_M_nfa, __alt, __tmp._M_end)); } __e._M_append(__end); while (!__stack.empty()) { auto& __tmp = (*_M_nfa)[__stack.top()]; __stack.pop(); std::swap(__tmp._M_next, __tmp._M_alt); } } _M_stack.push(__e); } else return false; return true; } # 311 "/usr/include/c++/10/bits/regex_compiler.tcc" 3 template bool _Compiler<_TraitsT>:: _M_atom() { if (_M_match_token(_ScannerT::_S_token_anychar)) { if (!(_M_flags & regex_constants::ECMAScript)) do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_posix(); else _M_insert_any_matcher_posix(); else if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_posix(); else _M_insert_any_matcher_posix(); } while (false); else do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_ecma(); else _M_insert_any_matcher_ecma(); else if (!(_M_flags & regex_constants::collate)) _M_insert_any_matcher_ecma(); else _M_insert_any_matcher_ecma(); } while (false); } else if (_M_try_char()) do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_char_matcher(); else _M_insert_char_matcher(); else if (!(_M_flags & regex_constants::collate)) _M_insert_char_matcher(); else _M_insert_char_matcher(); } while (false); else if (_M_match_token(_ScannerT::_S_token_backref)) _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa-> _M_insert_backref(_M_cur_int_value(10)))); else if (_M_match_token(_ScannerT::_S_token_quoted_class)) do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_character_class_matcher(); else _M_insert_character_class_matcher(); else if (!(_M_flags & regex_constants::collate)) _M_insert_character_class_matcher(); else _M_insert_character_class_matcher(); } while (false); else if (_M_match_token(_ScannerT::_S_token_subexpr_no_group_begin)) { _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_dummy()); this->_M_disjunction(); if (!_M_match_token(_ScannerT::_S_token_subexpr_end)) __throw_regex_error(regex_constants::error_paren, "Parenthesis is not closed."); __r._M_append(_M_pop()); _M_stack.push(__r); } else if (_M_match_token(_ScannerT::_S_token_subexpr_begin)) { _StateSeqT __r(*_M_nfa, _M_nfa->_M_insert_subexpr_begin()); this->_M_disjunction(); if (!_M_match_token(_ScannerT::_S_token_subexpr_end)) __throw_regex_error(regex_constants::error_paren, "Parenthesis is not closed."); __r._M_append(_M_pop()); __r._M_append(_M_nfa->_M_insert_subexpr_end()); _M_stack.push(__r); } else if (!_M_bracket_expression()) return false; return true; } template bool _Compiler<_TraitsT>:: _M_bracket_expression() { bool __neg = _M_match_token(_ScannerT::_S_token_bracket_neg_begin); if (!(__neg || _M_match_token(_ScannerT::_S_token_bracket_begin))) return false; do { if (!(_M_flags & regex_constants::icase)) if (!(_M_flags & regex_constants::collate)) _M_insert_bracket_matcher(__neg); else _M_insert_bracket_matcher(__neg); else if (!(_M_flags & regex_constants::collate)) _M_insert_bracket_matcher(__neg); else _M_insert_bracket_matcher(__neg); } while (false); return true; } template template void _Compiler<_TraitsT>:: _M_insert_any_matcher_ecma() { _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_matcher (_AnyMatcher<_TraitsT, true, __icase, __collate> (_M_traits)))); } template template void _Compiler<_TraitsT>:: _M_insert_any_matcher_posix() { _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_matcher (_AnyMatcher<_TraitsT, false, __icase, __collate> (_M_traits)))); } template template void _Compiler<_TraitsT>:: _M_insert_char_matcher() { _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_matcher (_CharMatcher<_TraitsT, __icase, __collate> (_M_value[0], _M_traits)))); } template template void _Compiler<_TraitsT>:: _M_insert_character_class_matcher() { ; _BracketMatcher<_TraitsT, __icase, __collate> __matcher (_M_ctype.is(_CtypeT::upper, _M_value[0]), _M_traits); __matcher._M_add_character_class(_M_value, false); __matcher._M_ready(); _M_stack.push(_StateSeqT(*_M_nfa, _M_nfa->_M_insert_matcher(std::move(__matcher)))); } template template void _Compiler<_TraitsT>:: _M_insert_bracket_matcher(bool __neg) { _BracketMatcher<_TraitsT, __icase, __collate> __matcher(__neg, _M_traits); pair __last_char; __last_char.first = false; if (!(_M_flags & regex_constants::ECMAScript)) { if (_M_try_char()) { __last_char.first = true; __last_char.second = _M_value[0]; } else if (_M_match_token(_ScannerT::_S_token_bracket_dash)) { __last_char.first = true; __last_char.second = '-'; } } while (_M_expression_term(__last_char, __matcher)); if (__last_char.first) __matcher._M_add_char(__last_char.second); __matcher._M_ready(); _M_stack.push(_StateSeqT( *_M_nfa, _M_nfa->_M_insert_matcher(std::move(__matcher)))); } template template bool _Compiler<_TraitsT>:: _M_expression_term(pair& __last_char, _BracketMatcher<_TraitsT, __icase, __collate>& __matcher) { if (_M_match_token(_ScannerT::_S_token_bracket_end)) return false; const auto __push_char = [&](_CharT __ch) { if (__last_char.first) __matcher._M_add_char(__last_char.second); else __last_char.first = true; __last_char.second = __ch; }; const auto __flush = [&] { if (__last_char.first) { __matcher._M_add_char(__last_char.second); __last_char.first = false; } }; if (_M_match_token(_ScannerT::_S_token_collsymbol)) { auto __symbol = __matcher._M_add_collate_element(_M_value); if (__symbol.size() == 1) __push_char(__symbol[0]); else __flush(); } else if (_M_match_token(_ScannerT::_S_token_equiv_class_name)) { __flush(); __matcher._M_add_equivalence_class(_M_value); } else if (_M_match_token(_ScannerT::_S_token_char_class_name)) { __flush(); __matcher._M_add_character_class(_M_value, false); } else if (_M_try_char()) __push_char(_M_value[0]); # 509 "/usr/include/c++/10/bits/regex_compiler.tcc" 3 else if (_M_match_token(_ScannerT::_S_token_bracket_dash)) { if (!__last_char.first) { if (!(_M_flags & regex_constants::ECMAScript)) { if (_M_match_token(_ScannerT::_S_token_bracket_end)) { __push_char('-'); return false; } __throw_regex_error( regex_constants::error_range, "Unexpected dash in bracket expression. For POSIX syntax, " "a dash is not treated literally only when it is at " "beginning or end."); } __push_char('-'); } else { if (_M_try_char()) { __matcher._M_make_range(__last_char.second, _M_value[0]); __last_char.first = false; } else if (_M_match_token(_ScannerT::_S_token_bracket_dash)) { __matcher._M_make_range(__last_char.second, '-'); __last_char.first = false; } else { if (_M_scanner._M_get_token() != _ScannerT::_S_token_bracket_end) __throw_regex_error( regex_constants::error_range, "Character is expected after a dash."); __push_char('-'); } } } else if (_M_match_token(_ScannerT::_S_token_quoted_class)) { __flush(); __matcher._M_add_character_class(_M_value, _M_ctype.is(_CtypeT::upper, _M_value[0])); } else __throw_regex_error(regex_constants::error_brack, "Unexpected character in bracket expression."); return true; } template bool _Compiler<_TraitsT>:: _M_try_char() { bool __is_char = false; if (_M_match_token(_ScannerT::_S_token_oct_num)) { __is_char = true; _M_value.assign(1, _M_cur_int_value(8)); } else if (_M_match_token(_ScannerT::_S_token_hex_num)) { __is_char = true; _M_value.assign(1, _M_cur_int_value(16)); } else if (_M_match_token(_ScannerT::_S_token_ord_char)) __is_char = true; return __is_char; } template bool _Compiler<_TraitsT>:: _M_match_token(_TokenT token) { if (token == _M_scanner._M_get_token()) { _M_value = _M_scanner._M_get_value(); _M_scanner._M_advance(); return true; } return false; } template int _Compiler<_TraitsT>:: _M_cur_int_value(int __radix) { long __v = 0; for (typename _StringT::size_type __i = 0; __i < _M_value.length(); ++__i) __v =__v * __radix + _M_traits.value(_M_value[__i], __radix); return __v; } template bool _BracketMatcher<_TraitsT, __icase, __collate>:: _M_apply(_CharT __ch, false_type) const { return [this, __ch] { if (std::binary_search(_M_char_set.begin(), _M_char_set.end(), _M_translator._M_translate(__ch))) return true; auto __s = _M_translator._M_transform(__ch); for (auto& __it : _M_range_set) if (_M_translator._M_match_range(__it.first, __it.second, __s)) return true; if (_M_traits.isctype(__ch, _M_class_set)) return true; if (std::find(_M_equiv_set.begin(), _M_equiv_set.end(), _M_traits.transform_primary(&__ch, &__ch+1)) != _M_equiv_set.end()) return true; for (auto& __it : _M_neg_class_set) if (!_M_traits.isctype(__ch, __it)) return true; return false; }() ^ _M_is_non_matching; } } } # 561 "/usr/include/c++/10/bits/regex_compiler.h" 2 3 # 62 "/usr/include/c++/10/regex" 2 3 # 1 "/usr/include/c++/10/bits/regex.h" 1 3 # 31 "/usr/include/c++/10/bits/regex.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __cxx11 { template class basic_regex; template class match_results; } namespace __detail { enum class _RegexExecutorPolicy : int { _S_auto, _S_alternate }; template bool __regex_algo_impl(_BiIter __s, _BiIter __e, match_results<_BiIter, _Alloc>& __m, const basic_regex<_CharT, _TraitsT>& __re, regex_constants::match_flag_type __flags); template class _Executor; } namespace __cxx11 { # 79 "/usr/include/c++/10/bits/regex.h" 3 template struct regex_traits { public: typedef _Ch_type char_type; typedef std::basic_string string_type; typedef std::locale locale_type; private: struct _RegexMask { typedef std::ctype_base::mask _BaseType; _BaseType _M_base; unsigned char _M_extended; static constexpr unsigned char _S_under = 1 << 0; static constexpr unsigned char _S_valid_mask = 0x1; constexpr _RegexMask(_BaseType __base = 0, unsigned char __extended = 0) : _M_base(__base), _M_extended(__extended) { } constexpr _RegexMask operator&(_RegexMask __other) const { return _RegexMask(_M_base & __other._M_base, _M_extended & __other._M_extended); } constexpr _RegexMask operator|(_RegexMask __other) const { return _RegexMask(_M_base | __other._M_base, _M_extended | __other._M_extended); } constexpr _RegexMask operator^(_RegexMask __other) const { return _RegexMask(_M_base ^ __other._M_base, _M_extended ^ __other._M_extended); } constexpr _RegexMask operator~() const { return _RegexMask(~_M_base, ~_M_extended); } _RegexMask& operator&=(_RegexMask __other) { return *this = (*this) & __other; } _RegexMask& operator|=(_RegexMask __other) { return *this = (*this) | __other; } _RegexMask& operator^=(_RegexMask __other) { return *this = (*this) ^ __other; } constexpr bool operator==(_RegexMask __other) const { return (_M_extended & _S_valid_mask) == (__other._M_extended & _S_valid_mask) && _M_base == __other._M_base; } }; public: typedef _RegexMask char_class_type; public: regex_traits() { } # 171 "/usr/include/c++/10/bits/regex.h" 3 static std::size_t length(const char_type* __p) { return string_type::traits_type::length(__p); } # 182 "/usr/include/c++/10/bits/regex.h" 3 char_type translate(char_type __c) const { return __c; } # 195 "/usr/include/c++/10/bits/regex.h" 3 char_type translate_nocase(char_type __c) const { typedef std::ctype __ctype_type; const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); return __fctyp.tolower(__c); } # 223 "/usr/include/c++/10/bits/regex.h" 3 template string_type transform(_Fwd_iter __first, _Fwd_iter __last) const { typedef std::collate __collate_type; const __collate_type& __fclt(use_facet<__collate_type>(_M_locale)); string_type __s(__first, __last); return __fclt.transform(__s.data(), __s.data() + __s.size()); } # 247 "/usr/include/c++/10/bits/regex.h" 3 template string_type transform_primary(_Fwd_iter __first, _Fwd_iter __last) const { typedef std::ctype __ctype_type; const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); std::vector __s(__first, __last); __fctyp.tolower(__s.data(), __s.data() + __s.size()); return this->transform(__s.data(), __s.data() + __s.size()); } # 275 "/usr/include/c++/10/bits/regex.h" 3 template string_type lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const; # 316 "/usr/include/c++/10/bits/regex.h" 3 template char_class_type lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase = false) const; # 333 "/usr/include/c++/10/bits/regex.h" 3 bool isctype(_Ch_type __c, char_class_type __f) const; # 346 "/usr/include/c++/10/bits/regex.h" 3 int value(_Ch_type __ch, int __radix) const; # 360 "/usr/include/c++/10/bits/regex.h" 3 locale_type imbue(locale_type __loc) { std::swap(_M_locale, __loc); return __loc; } locale_type getloc() const { return _M_locale; } protected: locale_type _M_locale; }; # 387 "/usr/include/c++/10/bits/regex.h" 3 template> class basic_regex { public: static_assert(is_same<_Ch_type, typename _Rx_traits::char_type>::value, "regex traits class must have the same char_type"); typedef _Ch_type value_type; typedef _Rx_traits traits_type; typedef typename traits_type::string_type string_type; typedef regex_constants::syntax_option_type flag_type; typedef typename traits_type::locale_type locale_type; static constexpr flag_type icase = regex_constants::icase; static constexpr flag_type nosubs = regex_constants::nosubs; static constexpr flag_type optimize = regex_constants::optimize; static constexpr flag_type collate = regex_constants::collate; static constexpr flag_type ECMAScript = regex_constants::ECMAScript; static constexpr flag_type basic = regex_constants::basic; static constexpr flag_type extended = regex_constants::extended; static constexpr flag_type awk = regex_constants::awk; static constexpr flag_type grep = regex_constants::grep; static constexpr flag_type egrep = regex_constants::egrep; basic_regex() : _M_flags(ECMAScript), _M_loc(), _M_automaton(nullptr) { } # 438 "/usr/include/c++/10/bits/regex.h" 3 explicit basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript) : basic_regex(__p, __p + char_traits<_Ch_type>::length(__p), __f) { } # 455 "/usr/include/c++/10/bits/regex.h" 3 basic_regex(const _Ch_type* __p, std::size_t __len, flag_type __f = ECMAScript) : basic_regex(__p, __p + __len, __f) { } basic_regex(const basic_regex& __rhs) = default; basic_regex(basic_regex&& __rhs) noexcept = default; # 483 "/usr/include/c++/10/bits/regex.h" 3 template explicit basic_regex(const std::basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, flag_type __f = ECMAScript) : basic_regex(__s.data(), __s.data() + __s.size(), __f) { } # 504 "/usr/include/c++/10/bits/regex.h" 3 template basic_regex(_FwdIter __first, _FwdIter __last, flag_type __f = ECMAScript) : basic_regex(std::move(__first), std::move(__last), locale_type(), __f) { } # 518 "/usr/include/c++/10/bits/regex.h" 3 basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript) : basic_regex(__l.begin(), __l.end(), __f) { } ~basic_regex() { } basic_regex& operator=(const basic_regex& __rhs) { return this->assign(__rhs); } basic_regex& operator=(basic_regex&& __rhs) noexcept { return this->assign(std::move(__rhs)); } # 549 "/usr/include/c++/10/bits/regex.h" 3 basic_regex& operator=(const _Ch_type* __p) { return this->assign(__p); } # 561 "/usr/include/c++/10/bits/regex.h" 3 basic_regex& operator=(initializer_list<_Ch_type> __l) { return this->assign(__l.begin(), __l.end()); } template basic_regex& operator=(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s) { return this->assign(__s); } basic_regex& assign(const basic_regex& __rhs) { basic_regex __tmp(__rhs); this->swap(__tmp); return *this; } basic_regex& assign(basic_regex&& __rhs) noexcept { basic_regex __tmp(std::move(__rhs)); this->swap(__tmp); return *this; } # 616 "/usr/include/c++/10/bits/regex.h" 3 basic_regex& assign(const _Ch_type* __p, flag_type __flags = ECMAScript) { return this->assign(string_type(__p), __flags); } # 635 "/usr/include/c++/10/bits/regex.h" 3 basic_regex& assign(const _Ch_type* __p, size_t __len, flag_type __flags = ECMAScript) { return this->assign(string_type(__p, __len), __flags); } # 650 "/usr/include/c++/10/bits/regex.h" 3 template basic_regex& assign(const basic_string<_Ch_type, _Ch_traits, _Alloc>& __s, flag_type __flags = ECMAScript) { return this->assign(basic_regex(__s.data(), __s.data() + __s.size(), _M_loc, __flags)); } # 672 "/usr/include/c++/10/bits/regex.h" 3 template basic_regex& assign(_InputIterator __first, _InputIterator __last, flag_type __flags = ECMAScript) { return this->assign(string_type(__first, __last), __flags); } # 689 "/usr/include/c++/10/bits/regex.h" 3 basic_regex& assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript) { return this->assign(__l.begin(), __l.end(), __flags); } unsigned int mark_count() const { if (_M_automaton) return _M_automaton->_M_sub_count() - 1; return 0; } flag_type flags() const { return _M_flags; } locale_type imbue(locale_type __loc) { std::swap(__loc, _M_loc); _M_automaton.reset(); return __loc; } locale_type getloc() const { return _M_loc; } void swap(basic_regex& __rhs) { std::swap(_M_flags, __rhs._M_flags); std::swap(_M_loc, __rhs._M_loc); std::swap(_M_automaton, __rhs._M_automaton); } private: typedef std::shared_ptr> _AutomatonPtr; template basic_regex(_FwdIter __first, _FwdIter __last, locale_type __loc, flag_type __f) : _M_flags(__f), _M_loc(std::move(__loc)), _M_automaton(__detail::__compile_nfa<_Rx_traits>( std::move(__first), std::move(__last), _M_loc, _M_flags)) { } template friend bool __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Rp>&, regex_constants::match_flag_type); template friend class __detail::_Executor; flag_type _M_flags; locale_type _M_loc; _AutomatonPtr _M_automaton; }; # 825 "/usr/include/c++/10/bits/regex.h" 3 template basic_regex(_ForwardIterator, _ForwardIterator, regex_constants::syntax_option_type = {}) -> basic_regex::value_type>; typedef basic_regex regex; typedef basic_regex wregex; # 847 "/usr/include/c++/10/bits/regex.h" 3 template inline void swap(basic_regex<_Ch_type, _Rx_traits>& __lhs, basic_regex<_Ch_type, _Rx_traits>& __rhs) { __lhs.swap(__rhs); } # 867 "/usr/include/c++/10/bits/regex.h" 3 template class sub_match : public std::pair<_BiIter, _BiIter> { typedef iterator_traits<_BiIter> __iter_traits; public: typedef typename __iter_traits::value_type value_type; typedef typename __iter_traits::difference_type difference_type; typedef _BiIter iterator; typedef basic_string string_type; bool matched; constexpr sub_match() noexcept : matched() { } difference_type length() const noexcept { return this->matched ? std::distance(this->first, this->second) : 0; } # 897 "/usr/include/c++/10/bits/regex.h" 3 operator string_type() const { return str(); } string_type str() const { return this->matched ? string_type(this->first, this->second) : string_type(); } # 922 "/usr/include/c++/10/bits/regex.h" 3 int compare(const sub_match& __s) const { return this->_M_str().compare(__s._M_str()); } # 936 "/usr/include/c++/10/bits/regex.h" 3 int compare(const string_type& __s) const { return this->_M_str().compare(__s); } int compare(const value_type* __s) const { return this->_M_str().compare(__s); } int _M_compare(const value_type* __s, size_t __n) const { return this->_M_str().compare({__s, __n}); } private: struct __string_view { using traits_type = typename string_type::traits_type; __string_view() = default; __string_view(const value_type* __s, size_t __n) noexcept : _M_data(__s), _M_len(__n) { } __string_view(const value_type* __s) noexcept : _M_data(__s), _M_len(traits_type::length(__s)) { } __string_view(const string_type& __s) noexcept : _M_data(__s.data()), _M_len(__s.length()) { } int compare(__string_view __s) const noexcept { if (const size_t __n = std::min(_M_len, __s._M_len)) if (int __ret = traits_type::compare(_M_data, __s._M_data, __n)) return __ret; const difference_type __diff = _M_len - __s._M_len; if (__diff > std::numeric_limits::max()) return std::numeric_limits::max(); if (__diff < std::numeric_limits::min()) return std::numeric_limits::min(); return static_cast(__diff); } private: const value_type* _M_data = nullptr; size_t _M_len = 0; }; template __enable_if_t<__detail::__is_contiguous_iter<_Iter>::value, __string_view> _M_str() const noexcept { if (this->matched) if (auto __len = this->second - this->first) return { std::__addressof(*this->first), __len }; return {}; } template __enable_if_t::value, string_type> _M_str() const { return str(); } }; typedef sub_match csub_match; typedef sub_match ssub_match; typedef sub_match wcsub_match; typedef sub_match wssub_match; # 1033 "/usr/include/c++/10/bits/regex.h" 3 template inline bool operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) { return __lhs.compare(__rhs) == 0; } # 1046 "/usr/include/c++/10/bits/regex.h" 3 template inline auto operator<=>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) noexcept(__detail::__is_contiguous_iter<_BiIter>::value) { using _Tr = char_traits::value_type>; return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs)); } # 1115 "/usr/include/c++/10/bits/regex.h" 3 template using __sub_match_string = basic_string< typename iterator_traits<_Bi_iter>::value_type, _Ch_traits, _Ch_alloc>; # 1204 "/usr/include/c++/10/bits/regex.h" 3 template inline bool operator==(const sub_match<_Bi_iter>& __lhs, const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs) { return __lhs._M_compare(__rhs.data(), __rhs.size()) == 0; } # 1218 "/usr/include/c++/10/bits/regex.h" 3 template inline auto operator<=>(const sub_match<_Bi_iter>& __lhs, const __sub_match_string<_Bi_iter, _Ch_traits, _Alloc>& __rhs) noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value) { return __detail::__char_traits_cmp_cat<_Ch_traits>( __lhs._M_compare(__rhs.data(), __rhs.size())); } # 1371 "/usr/include/c++/10/bits/regex.h" 3 template inline bool operator==(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) { return __lhs.compare(__rhs) == 0; } # 1386 "/usr/include/c++/10/bits/regex.h" 3 template inline auto operator<=>(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const* __rhs) noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value) { using _Tr = char_traits::value_type>; return __detail::__char_traits_cmp_cat<_Tr>(__lhs.compare(__rhs)); } # 1543 "/usr/include/c++/10/bits/regex.h" 3 template inline bool operator==(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) { return __lhs._M_compare(std::__addressof(__rhs), 1) == 0; } # 1559 "/usr/include/c++/10/bits/regex.h" 3 template inline auto operator<=>(const sub_match<_Bi_iter>& __lhs, typename iterator_traits<_Bi_iter>::value_type const& __rhs) noexcept(__detail::__is_contiguous_iter<_Bi_iter>::value) { using _Tr = char_traits::value_type>; return __detail::__char_traits_cmp_cat<_Tr>( __lhs._M_compare(std::__addressof(__rhs), 1)); } # 1644 "/usr/include/c++/10/bits/regex.h" 3 template inline basic_ostream<_Ch_type, _Ch_traits>& operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os, const sub_match<_Bi_iter>& __m) { return __os << __m.str(); } # 1675 "/usr/include/c++/10/bits/regex.h" 3 template > > class match_results : private std::vector, _Alloc> { private: # 1697 "/usr/include/c++/10/bits/regex.h" 3 typedef std::vector, _Alloc> _Base_type; typedef std::iterator_traits<_Bi_iter> __iter_traits; typedef regex_constants::match_flag_type match_flag_type; public: typedef sub_match<_Bi_iter> value_type; typedef const value_type& const_reference; typedef value_type& reference; typedef typename _Base_type::const_iterator const_iterator; typedef const_iterator iterator; typedef typename __iter_traits::difference_type difference_type; typedef typename allocator_traits<_Alloc>::size_type size_type; typedef _Alloc allocator_type; typedef typename __iter_traits::value_type char_type; typedef std::basic_string string_type; public: # 1728 "/usr/include/c++/10/bits/regex.h" 3 match_results() : match_results(_Alloc()) { } explicit match_results(const _Alloc& __a) noexcept : _Base_type(__a) { } match_results(const match_results&) = default; match_results(match_results&&) noexcept = default; match_results& operator=(const match_results&) = default; match_results& operator=(match_results&&) = default; ~match_results() = default; # 1774 "/usr/include/c++/10/bits/regex.h" 3 bool ready() const noexcept { return !_Base_type::empty(); } # 1790 "/usr/include/c++/10/bits/regex.h" 3 size_type size() const noexcept { return _Base_type::empty() ? 0 : _Base_type::size() - 3; } size_type max_size() const noexcept { return _Base_type::max_size() - 3; } [[__nodiscard__]] bool empty() const noexcept { return size() == 0; } # 1822 "/usr/include/c++/10/bits/regex.h" 3 difference_type length(size_type __sub = 0) const { return (*this)[__sub].length(); } # 1837 "/usr/include/c++/10/bits/regex.h" 3 difference_type position(size_type __sub = 0) const { return std::distance(_M_begin, (*this)[__sub].first); } # 1850 "/usr/include/c++/10/bits/regex.h" 3 string_type str(size_type __sub = 0) const { return string_type((*this)[__sub]); } # 1865 "/usr/include/c++/10/bits/regex.h" 3 const_reference operator[](size_type __sub) const { ; return __sub < size() ? _Base_type::operator[](__sub) : _M_unmatched_sub(); } # 1882 "/usr/include/c++/10/bits/regex.h" 3 const_reference prefix() const { ; return !empty() ? _M_prefix() : _M_unmatched_sub(); } # 1897 "/usr/include/c++/10/bits/regex.h" 3 const_reference suffix() const { ; return !empty() ? _M_suffix() : _M_unmatched_sub(); } const_iterator begin() const noexcept { return _Base_type::begin(); } const_iterator cbegin() const noexcept { return this->begin(); } const_iterator end() const noexcept { return _Base_type::end() - (empty() ? 0 : 3); } const_iterator cend() const noexcept { return this->end(); } # 1947 "/usr/include/c++/10/bits/regex.h" 3 template _Out_iter format(_Out_iter __out, const char_type* __fmt_first, const char_type* __fmt_last, match_flag_type __flags = regex_constants::format_default) const; template _Out_iter format(_Out_iter __out, const basic_string& __fmt, match_flag_type __flags = regex_constants::format_default) const { return format(__out, __fmt.data(), __fmt.data() + __fmt.size(), __flags); } template basic_string format(const basic_string& __fmt, match_flag_type __flags = regex_constants::format_default) const { basic_string __result; format(std::back_inserter(__result), __fmt, __flags); return __result; } string_type format(const char_type* __fmt, match_flag_type __flags = regex_constants::format_default) const { string_type __result; format(std::back_inserter(__result), __fmt, __fmt + char_traits::length(__fmt), __flags); return __result; } # 2003 "/usr/include/c++/10/bits/regex.h" 3 allocator_type get_allocator() const noexcept { return _Base_type::get_allocator(); } # 2017 "/usr/include/c++/10/bits/regex.h" 3 void swap(match_results& __that) noexcept { using std::swap; _Base_type::swap(__that); swap(_M_begin, __that._M_begin); } private: template friend class regex_iterator; template friend class __detail::_Executor; template friend bool __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Rp>&, regex_constants::match_flag_type); void _M_resize(unsigned int __size) { _Base_type::assign(__size + 3, sub_match<_Bi_iter>{}); } void _M_establish_failed_match(_Bi_iter __end) { sub_match<_Bi_iter> __sm; __sm.first = __sm.second = __end; _Base_type::assign(3, __sm); } const_reference _M_unmatched_sub() const { return _Base_type::operator[](_Base_type::size() - 3); } sub_match<_Bi_iter>& _M_unmatched_sub() { return _Base_type::operator[](_Base_type::size() - 3); } const_reference _M_prefix() const { return _Base_type::operator[](_Base_type::size() - 2); } sub_match<_Bi_iter>& _M_prefix() { return _Base_type::operator[](_Base_type::size() - 2); } const_reference _M_suffix() const { return _Base_type::operator[](_Base_type::size() - 1); } sub_match<_Bi_iter>& _M_suffix() { return _Base_type::operator[](_Base_type::size() - 1); } _Bi_iter _M_begin; }; typedef match_results cmatch; typedef match_results smatch; typedef match_results wcmatch; typedef match_results wsmatch; # 2099 "/usr/include/c++/10/bits/regex.h" 3 template inline bool operator==(const match_results<_Bi_iter, _Alloc>& __m1, const match_results<_Bi_iter, _Alloc>& __m2) { if (__m1.ready() != __m2.ready()) return false; if (!__m1.ready()) return true; if (__m1.empty() != __m2.empty()) return false; if (__m1.empty()) return true; return __m1.prefix() == __m2.prefix() && __m1.size() == __m2.size() && std::equal(__m1.begin(), __m1.end(), __m2.begin()) && __m1.suffix() == __m2.suffix(); } # 2139 "/usr/include/c++/10/bits/regex.h" 3 template inline void swap(match_results<_Bi_iter, _Alloc>& __lhs, match_results<_Bi_iter, _Alloc>& __rhs) noexcept { __lhs.swap(__rhs); } } # 2168 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_match(_Bi_iter __s, _Bi_iter __e, match_results<_Bi_iter, _Alloc>& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits, __detail::_RegexExecutorPolicy::_S_auto, true> (__s, __e, __m, __re, __flags); } # 2197 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_match(_Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { match_results<_Bi_iter> __what; return regex_match(__first, __last, __what, __re, __flags); } # 2222 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_match(const _Ch_type* __s, match_results& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); } # 2245 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, match_results::const_iterator, _Alloc>& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); } template bool regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&, match_results::const_iterator, _Alloc>&, const basic_regex<_Ch_type, _Rx_traits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete; # 2282 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_match(const _Ch_type* __s, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); } # 2303 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { return regex_match(__s.begin(), __s.end(), __re, __flags); } # 2326 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_search(_Bi_iter __s, _Bi_iter __e, match_results<_Bi_iter, _Alloc>& __m, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits, __detail::_RegexExecutorPolicy::_S_auto, false> (__s, __e, __m, __re, __flags); } # 2351 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_search(_Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __re, regex_constants::match_flag_type __flags = regex_constants::match_default) { match_results<_Bi_iter> __what; return regex_search(__first, __last, __what, __re, __flags); } # 2374 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_search(const _Ch_type* __s, match_results& __m, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); } # 2393 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_search(const _Ch_type* __s, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); } # 2411 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_search(const basic_string<_Ch_type, _Ch_traits, _String_allocator>& __s, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __flags = regex_constants::match_default) { return regex_search(__s.begin(), __s.end(), __e, __flags); } # 2433 "/usr/include/c++/10/bits/regex.h" 3 template inline bool regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, match_results::const_iterator, _Alloc>& __m, const basic_regex<_Ch_type, _Rx_traits>& __e, regex_constants::match_flag_type __f = regex_constants::match_default) { return regex_search(__s.begin(), __s.end(), __m, __e, __f); } template bool regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>&&, match_results::const_iterator, _Alloc>&, const basic_regex<_Ch_type, _Rx_traits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete; # 2473 "/usr/include/c++/10/bits/regex.h" 3 template inline _Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __e, const basic_string<_Ch_type, _St, _Sa>& __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { return regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags); } # 2499 "/usr/include/c++/10/bits/regex.h" 3 template _Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __e, const _Ch_type* __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default); # 2519 "/usr/include/c++/10/bits/regex.h" 3 template inline basic_string<_Ch_type, _St, _Sa> regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s, const basic_regex<_Ch_type, _Rx_traits>& __e, const basic_string<_Ch_type, _Fst, _Fsa>& __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { basic_string<_Ch_type, _St, _Sa> __result; regex_replace(std::back_inserter(__result), __s.begin(), __s.end(), __e, __fmt, __flags); return __result; } # 2545 "/usr/include/c++/10/bits/regex.h" 3 template inline basic_string<_Ch_type, _St, _Sa> regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s, const basic_regex<_Ch_type, _Rx_traits>& __e, const _Ch_type* __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { basic_string<_Ch_type, _St, _Sa> __result; regex_replace(std::back_inserter(__result), __s.begin(), __s.end(), __e, __fmt, __flags); return __result; } # 2571 "/usr/include/c++/10/bits/regex.h" 3 template inline basic_string<_Ch_type> regex_replace(const _Ch_type* __s, const basic_regex<_Ch_type, _Rx_traits>& __e, const basic_string<_Ch_type, _St, _Sa>& __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { basic_string<_Ch_type> __result; regex_replace(std::back_inserter(__result), __s, __s + char_traits<_Ch_type>::length(__s), __e, __fmt, __flags); return __result; } # 2598 "/usr/include/c++/10/bits/regex.h" 3 template inline basic_string<_Ch_type> regex_replace(const _Ch_type* __s, const basic_regex<_Ch_type, _Rx_traits>& __e, const _Ch_type* __fmt, regex_constants::match_flag_type __flags = regex_constants::match_default) { basic_string<_Ch_type> __result; regex_replace(std::back_inserter(__result), __s, __s + char_traits<_Ch_type>::length(__s), __e, __fmt, __flags); return __result; } namespace __cxx11 { template::value_type, typename _Rx_traits = regex_traits<_Ch_type> > class regex_iterator { public: typedef basic_regex<_Ch_type, _Rx_traits> regex_type; typedef match_results<_Bi_iter> value_type; typedef std::ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; typedef std::forward_iterator_tag iterator_category; regex_iterator() = default; # 2648 "/usr/include/c++/10/bits/regex.h" 3 regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, regex_constants::match_flag_type __m = regex_constants::match_default) : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match() { if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags)) *this = regex_iterator(); } regex_iterator(_Bi_iter, _Bi_iter, const regex_type&&, regex_constants::match_flag_type = regex_constants::match_default) = delete; regex_iterator(const regex_iterator&) = default; regex_iterator& operator=(const regex_iterator&) = default; ~regex_iterator() = default; bool operator==(const regex_iterator&) const noexcept; bool operator!=(const regex_iterator& __rhs) const noexcept { return !(*this == __rhs); } const value_type& operator*() const noexcept { return _M_match; } const value_type* operator->() const noexcept { return &_M_match; } regex_iterator& operator++(); regex_iterator operator++(int) { auto __tmp = *this; ++(*this); return __tmp; } private: _Bi_iter _M_begin {}; _Bi_iter _M_end {}; const regex_type* _M_pregex = nullptr; regex_constants::match_flag_type _M_flags {}; match_results<_Bi_iter> _M_match; }; typedef regex_iterator cregex_iterator; typedef regex_iterator sregex_iterator; typedef regex_iterator wcregex_iterator; typedef regex_iterator wsregex_iterator; # 2739 "/usr/include/c++/10/bits/regex.h" 3 template::value_type, typename _Rx_traits = regex_traits<_Ch_type> > class regex_token_iterator { public: typedef basic_regex<_Ch_type, _Rx_traits> regex_type; typedef sub_match<_Bi_iter> value_type; typedef std::ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; typedef std::forward_iterator_tag iterator_category; public: regex_token_iterator() : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr), _M_has_m1(false) { } # 2782 "/usr/include/c++/10/bits/regex.h" 3 regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, int __submatch = 0, regex_constants::match_flag_type __m = regex_constants::match_default) : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0) { _M_init(__a, __b); } # 2798 "/usr/include/c++/10/bits/regex.h" 3 regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, const std::vector& __submatches, regex_constants::match_flag_type __m = regex_constants::match_default) : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0) { _M_init(__a, __b); } # 2815 "/usr/include/c++/10/bits/regex.h" 3 regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, initializer_list __submatches, regex_constants::match_flag_type __m = regex_constants::match_default) : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0) { _M_init(__a, __b); } # 2832 "/usr/include/c++/10/bits/regex.h" 3 template regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, const int (&__submatches)[_Nm], regex_constants::match_flag_type __m = regex_constants::match_default) : _M_position(__a, __b, __re, __m), _M_subs(__submatches, __submatches + _Nm), _M_n(0) { _M_init(__a, __b); } regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, int = 0, regex_constants::match_flag_type = regex_constants::match_default) = delete; regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, const std::vector&, regex_constants::match_flag_type = regex_constants::match_default) = delete; regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, initializer_list, regex_constants::match_flag_type = regex_constants::match_default) = delete; template regex_token_iterator(_Bi_iter, _Bi_iter, const regex_type&&, const int (&)[_Nm], regex_constants::match_flag_type = regex_constants::match_default) = delete; regex_token_iterator(const regex_token_iterator& __rhs) : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs), _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1) { _M_normalize_result(); } regex_token_iterator& operator=(const regex_token_iterator& __rhs); bool operator==(const regex_token_iterator& __rhs) const; bool operator!=(const regex_token_iterator& __rhs) const { return !(*this == __rhs); } const value_type& operator*() const { return *_M_result; } const value_type* operator->() const { return _M_result; } regex_token_iterator& operator++(); regex_token_iterator operator++(int) { auto __tmp = *this; ++(*this); return __tmp; } private: typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _Position; void _M_init(_Bi_iter __a, _Bi_iter __b); const value_type& _M_current_match() const { if (_M_subs[_M_n] == -1) return (*_M_position).prefix(); else return (*_M_position)[_M_subs[_M_n]]; } constexpr bool _M_end_of_seq() const { return _M_result == nullptr; } void _M_normalize_result() { if (_M_position != _Position()) _M_result = &_M_current_match(); else if (_M_has_m1) _M_result = &_M_suffix; else _M_result = nullptr; } _Position _M_position; std::vector _M_subs; value_type _M_suffix; std::size_t _M_n; const value_type* _M_result; bool _M_has_m1; }; typedef regex_token_iterator cregex_token_iterator; typedef regex_token_iterator sregex_token_iterator; typedef regex_token_iterator wcregex_token_iterator; typedef regex_token_iterator wsregex_token_iterator; } } # 1 "/usr/include/c++/10/bits/regex.tcc" 1 3 # 31 "/usr/include/c++/10/bits/regex.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { # 45 "/usr/include/c++/10/bits/regex.tcc" 3 template bool __regex_algo_impl(_BiIter __s, _BiIter __e, match_results<_BiIter, _Alloc>& __m, const basic_regex<_CharT, _TraitsT>& __re, regex_constants::match_flag_type __flags) { if (__re._M_automaton == nullptr) return false; typename match_results<_BiIter, _Alloc>::_Base_type& __res = __m; __m._M_begin = __s; __m._M_resize(__re._M_automaton->_M_sub_count()); bool __ret; if ((__re.flags() & regex_constants::__polynomial) || (__policy == _RegexExecutorPolicy::_S_alternate && !__re._M_automaton->_M_has_backref)) { _Executor<_BiIter, _Alloc, _TraitsT, false> __executor(__s, __e, __m, __re, __flags); if (__match_mode) __ret = __executor._M_match(); else __ret = __executor._M_search(); } else { _Executor<_BiIter, _Alloc, _TraitsT, true> __executor(__s, __e, __m, __re, __flags); if (__match_mode) __ret = __executor._M_match(); else __ret = __executor._M_search(); } if (__ret) { for (auto& __it : __res) if (!__it.matched) __it.first = __it.second = __e; auto& __pre = __m._M_prefix(); auto& __suf = __m._M_suffix(); if (__match_mode) { __pre.matched = false; __pre.first = __s; __pre.second = __s; __suf.matched = false; __suf.first = __e; __suf.second = __e; } else { __pre.first = __s; __pre.second = __res[0].first; __pre.matched = (__pre.first != __pre.second); __suf.first = __res[0].second; __suf.second = __e; __suf.matched = (__suf.first != __suf.second); } } else { __m._M_establish_failed_match(__e); } return __ret; } } template template typename regex_traits<_Ch_type>::string_type regex_traits<_Ch_type>:: lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const { typedef std::ctype __ctype_type; const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); static const char* __collatenames[] = { "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "alert", "backspace", "tab", "newline", "vertical-tab", "form-feed", "carriage-return", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "IS4", "IS3", "IS2", "IS1", "space", "exclamation-mark", "quotation-mark", "number-sign", "dollar-sign", "percent-sign", "ampersand", "apostrophe", "left-parenthesis", "right-parenthesis", "asterisk", "plus-sign", "comma", "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon", "less-than-sign", "equals-sign", "greater-than-sign", "question-mark", "commercial-at", "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", "left-square-bracket", "backslash", "right-square-bracket", "circumflex", "underscore", "grave-accent", "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", "left-curly-bracket", "vertical-line", "right-curly-bracket", "tilde", "DEL", }; string __s; for (; __first != __last; ++__first) __s += __fctyp.narrow(*__first, 0); for (const auto& __it : __collatenames) if (__s == __it) return string_type(1, __fctyp.widen( static_cast(&__it - __collatenames))); return string_type(); } template template typename regex_traits<_Ch_type>::char_class_type regex_traits<_Ch_type>:: lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase) const { typedef std::ctype __ctype_type; const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); static const pair __classnames[] = { {"d", ctype_base::digit}, {"w", {ctype_base::alnum, _RegexMask::_S_under}}, {"s", ctype_base::space}, {"alnum", ctype_base::alnum}, {"alpha", ctype_base::alpha}, {"blank", ctype_base::blank}, {"cntrl", ctype_base::cntrl}, {"digit", ctype_base::digit}, {"graph", ctype_base::graph}, {"lower", ctype_base::lower}, {"print", ctype_base::print}, {"punct", ctype_base::punct}, {"space", ctype_base::space}, {"upper", ctype_base::upper}, {"xdigit", ctype_base::xdigit}, }; string __s; for (; __first != __last; ++__first) __s += __fctyp.narrow(__fctyp.tolower(*__first), 0); for (const auto& __it : __classnames) if (__s == __it.first) { if (__icase && ((__it.second & (ctype_base::lower | ctype_base::upper)) != 0)) return ctype_base::alpha; return __it.second; } return 0; } template bool regex_traits<_Ch_type>:: isctype(_Ch_type __c, char_class_type __f) const { typedef std::ctype __ctype_type; const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); return __fctyp.is(__f._M_base, __c) || ((__f._M_extended & _RegexMask::_S_under) && __c == __fctyp.widen('_')); } template int regex_traits<_Ch_type>:: value(_Ch_type __ch, int __radix) const { std::basic_istringstream __is(string_type(1, __ch)); long __v; if (__radix == 8) __is >> std::oct; else if (__radix == 16) __is >> std::hex; __is >> __v; return __is.fail() ? -1 : __v; } template template _Out_iter match_results<_Bi_iter, _Alloc>:: format(_Out_iter __out, const match_results<_Bi_iter, _Alloc>::char_type* __fmt_first, const match_results<_Bi_iter, _Alloc>::char_type* __fmt_last, match_flag_type __flags) const { ; regex_traits __traits; typedef std::ctype __ctype_type; const __ctype_type& __fctyp(use_facet<__ctype_type>(__traits.getloc())); auto __output = [&](size_t __idx) { auto& __sub = (*this)[__idx]; if (__sub.matched) __out = std::copy(__sub.first, __sub.second, __out); }; if (__flags & regex_constants::format_sed) { bool __escaping = false; for (; __fmt_first != __fmt_last; __fmt_first++) { if (__escaping) { __escaping = false; if (__fctyp.is(__ctype_type::digit, *__fmt_first)) __output(__traits.value(*__fmt_first, 10)); else *__out++ = *__fmt_first; continue; } if (*__fmt_first == '\\') { __escaping = true; continue; } if (*__fmt_first == '&') { __output(0); continue; } *__out++ = *__fmt_first; } if (__escaping) *__out++ = '\\'; } else { while (1) { auto __next = std::find(__fmt_first, __fmt_last, '$'); if (__next == __fmt_last) break; __out = std::copy(__fmt_first, __next, __out); auto __eat = [&](char __ch) -> bool { if (*__next == __ch) { ++__next; return true; } return false; }; if (++__next == __fmt_last) *__out++ = '$'; else if (__eat('$')) *__out++ = '$'; else if (__eat('&')) __output(0); else if (__eat('`')) { auto& __sub = _M_prefix(); if (__sub.matched) __out = std::copy(__sub.first, __sub.second, __out); } else if (__eat('\'')) { auto& __sub = _M_suffix(); if (__sub.matched) __out = std::copy(__sub.first, __sub.second, __out); } else if (__fctyp.is(__ctype_type::digit, *__next)) { long __num = __traits.value(*__next, 10); if (++__next != __fmt_last && __fctyp.is(__ctype_type::digit, *__next)) { __num *= 10; __num += __traits.value(*__next++, 10); } if (0 <= __num && __num < this->size()) __output(__num); } else *__out++ = '$'; __fmt_first = __next; } __out = std::copy(__fmt_first, __fmt_last, __out); } return __out; } template _Out_iter regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, const basic_regex<_Ch_type, _Rx_traits>& __e, const _Ch_type* __fmt, regex_constants::match_flag_type __flags) { typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _IterT; _IterT __i(__first, __last, __e, __flags); _IterT __end; if (__i == __end) { if (!(__flags & regex_constants::format_no_copy)) __out = std::copy(__first, __last, __out); } else { sub_match<_Bi_iter> __last; auto __len = char_traits<_Ch_type>::length(__fmt); for (; __i != __end; ++__i) { if (!(__flags & regex_constants::format_no_copy)) __out = std::copy(__i->prefix().first, __i->prefix().second, __out); __out = __i->format(__out, __fmt, __fmt + __len, __flags); __last = __i->suffix(); if (__flags & regex_constants::format_first_only) break; } if (!(__flags & regex_constants::format_no_copy)) __out = std::copy(__last.first, __last.second, __out); } return __out; } template bool regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: operator==(const regex_iterator& __rhs) const noexcept { if (_M_pregex == nullptr && __rhs._M_pregex == nullptr) return true; return _M_pregex == __rhs._M_pregex && _M_begin == __rhs._M_begin && _M_end == __rhs._M_end && _M_flags == __rhs._M_flags && _M_match[0] == __rhs._M_match[0]; } template regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>& regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: operator++() { if (_M_match[0].matched) { auto __start = _M_match[0].second; auto __prefix_first = _M_match[0].second; if (_M_match[0].first == _M_match[0].second) { if (__start == _M_end) { _M_pregex = nullptr; return *this; } else { if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags | regex_constants::match_not_null | regex_constants::match_continuous)) { ; auto& __prefix = _M_match._M_prefix(); __prefix.first = __prefix_first; __prefix.matched = __prefix.first != __prefix.second; _M_match._M_begin = _M_begin; return *this; } else ++__start; } } _M_flags |= regex_constants::match_prev_avail; if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags)) { ; auto& __prefix = _M_match._M_prefix(); __prefix.first = __prefix_first; __prefix.matched = __prefix.first != __prefix.second; _M_match._M_begin = _M_begin; } else _M_pregex = nullptr; } return *this; } template regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>& regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: operator=(const regex_token_iterator& __rhs) { _M_position = __rhs._M_position; _M_subs = __rhs._M_subs; _M_n = __rhs._M_n; _M_suffix = __rhs._M_suffix; _M_has_m1 = __rhs._M_has_m1; _M_normalize_result(); return *this; } template bool regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: operator==(const regex_token_iterator& __rhs) const { if (_M_end_of_seq() && __rhs._M_end_of_seq()) return true; if (_M_suffix.matched && __rhs._M_suffix.matched && _M_suffix == __rhs._M_suffix) return true; if (_M_end_of_seq() || _M_suffix.matched || __rhs._M_end_of_seq() || __rhs._M_suffix.matched) return false; return _M_position == __rhs._M_position && _M_n == __rhs._M_n && _M_subs == __rhs._M_subs; } template regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>& regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: operator++() { _Position __prev = _M_position; if (_M_suffix.matched) *this = regex_token_iterator(); else if (_M_n + 1 < _M_subs.size()) { _M_n++; _M_result = &_M_current_match(); } else { _M_n = 0; ++_M_position; if (_M_position != _Position()) _M_result = &_M_current_match(); else if (_M_has_m1 && __prev->suffix().length() != 0) { _M_suffix.matched = true; _M_suffix.first = __prev->suffix().first; _M_suffix.second = __prev->suffix().second; _M_result = &_M_suffix; } else *this = regex_token_iterator(); } return *this; } template void regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: _M_init(_Bi_iter __a, _Bi_iter __b) { _M_has_m1 = false; for (auto __it : _M_subs) if (__it == -1) { _M_has_m1 = true; break; } if (_M_position != _Position()) _M_result = &_M_current_match(); else if (_M_has_m1) { _M_suffix.matched = true; _M_suffix.first = __a; _M_suffix.second = __b; _M_result = &_M_suffix; } else _M_result = nullptr; } } # 2983 "/usr/include/c++/10/bits/regex.h" 2 3 # 63 "/usr/include/c++/10/regex" 2 3 # 1 "/usr/include/c++/10/bits/regex_executor.h" 1 3 # 33 "/usr/include/c++/10/bits/regex_executor.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { # 50 "/usr/include/c++/10/bits/regex_executor.h" 3 template class _Executor { using __search_mode = integral_constant; using __dfs = true_type; using __bfs = false_type; enum class _Match_mode : unsigned char { _Exact, _Prefix }; public: typedef typename iterator_traits<_BiIter>::value_type _CharT; typedef basic_regex<_CharT, _TraitsT> _RegexT; typedef std::vector, _Alloc> _ResultsVec; typedef regex_constants::match_flag_type _FlagT; typedef typename _TraitsT::char_class_type _ClassT; typedef _NFA<_TraitsT> _NFAT; public: _Executor(_BiIter __begin, _BiIter __end, _ResultsVec& __results, const _RegexT& __re, _FlagT __flags) : _M_begin(__begin), _M_end(__end), _M_re(__re), _M_nfa(*__re._M_automaton), _M_results(__results), _M_rep_count(_M_nfa.size()), _M_states(_M_nfa._M_start(), _M_nfa.size()), _M_flags((__flags & regex_constants::match_prev_avail) ? (__flags & ~regex_constants::match_not_bol & ~regex_constants::match_not_bow) : __flags) { } bool _M_match() { _M_current = _M_begin; return _M_main(_Match_mode::_Exact); } bool _M_search_from_first() { _M_current = _M_begin; return _M_main(_Match_mode::_Prefix); } bool _M_search(); private: void _M_rep_once_more(_Match_mode __match_mode, _StateIdT); void _M_handle_repeat(_Match_mode, _StateIdT); void _M_handle_subexpr_begin(_Match_mode, _StateIdT); void _M_handle_subexpr_end(_Match_mode, _StateIdT); void _M_handle_line_begin_assertion(_Match_mode, _StateIdT); void _M_handle_line_end_assertion(_Match_mode, _StateIdT); void _M_handle_word_boundary(_Match_mode, _StateIdT); void _M_handle_subexpr_lookahead(_Match_mode, _StateIdT); void _M_handle_match(_Match_mode, _StateIdT); void _M_handle_backref(_Match_mode, _StateIdT); void _M_handle_accept(_Match_mode, _StateIdT); void _M_handle_alternative(_Match_mode, _StateIdT); void _M_dfs(_Match_mode __match_mode, _StateIdT __start); bool _M_main(_Match_mode __match_mode) { return _M_main_dispatch(__match_mode, __search_mode{}); } bool _M_main_dispatch(_Match_mode __match_mode, __dfs); bool _M_main_dispatch(_Match_mode __match_mode, __bfs); bool _M_is_word(_CharT __ch) const { static const _CharT __s[2] = { 'w' }; return _M_re._M_automaton->_M_traits.isctype (__ch, _M_re._M_automaton->_M_traits.lookup_classname(__s, __s+1)); } bool _M_at_begin() const { return _M_current == _M_begin && !(_M_flags & (regex_constants::match_not_bol | regex_constants::match_prev_avail)); } bool _M_at_end() const { return _M_current == _M_end && !(_M_flags & regex_constants::match_not_eol); } bool _M_word_boundary() const; bool _M_lookahead(_StateIdT __next); template struct _State_info; template struct _State_info<__bfs, _ResultsVec> { explicit _State_info(_StateIdT __start, size_t __n) : _M_visited_states(new bool[__n]()), _M_start(__start) { } bool _M_visited(_StateIdT __i) { if (_M_visited_states[__i]) return true; _M_visited_states[__i] = true; return false; } void _M_queue(_StateIdT __i, const _ResultsVec& __res) { _M_match_queue.emplace_back(__i, __res); } _BiIter* _M_get_sol_pos() { return nullptr; } vector> _M_match_queue; unique_ptr _M_visited_states; _StateIdT _M_start; }; template struct _State_info<__dfs, _ResultsVec> { explicit _State_info(_StateIdT __start, size_t) : _M_start(__start) { } bool _M_visited(_StateIdT) const { return false; } void _M_queue(_StateIdT, const _ResultsVec&) { } _BiIter* _M_get_sol_pos() { return &_M_sol_pos; } _StateIdT _M_start; _BiIter _M_sol_pos; }; public: _ResultsVec _M_cur_results; _BiIter _M_current; _BiIter _M_begin; const _BiIter _M_end; const _RegexT& _M_re; const _NFAT& _M_nfa; _ResultsVec& _M_results; vector> _M_rep_count; _State_info<__search_mode, _ResultsVec> _M_states; _FlagT _M_flags; bool _M_has_sol; }; } } # 1 "/usr/include/c++/10/bits/regex_executor.tcc" 1 3 # 31 "/usr/include/c++/10/bits/regex_executor.tcc" 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace __detail { template bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_search() { if (_M_search_from_first()) return true; if (_M_flags & regex_constants::match_continuous) return false; _M_flags |= regex_constants::match_prev_avail; while (_M_begin != _M_end) { ++_M_begin; if (_M_search_from_first()) return true; } return false; } # 79 "/usr/include/c++/10/bits/regex_executor.tcc" 3 template bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_main_dispatch(_Match_mode __match_mode, __dfs) { _M_has_sol = false; *_M_states._M_get_sol_pos() = _BiIter(); _M_cur_results = _M_results; _M_dfs(__match_mode, _M_states._M_start); return _M_has_sol; } # 113 "/usr/include/c++/10/bits/regex_executor.tcc" 3 template bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_main_dispatch(_Match_mode __match_mode, __bfs) { _M_states._M_queue(_M_states._M_start, _M_results); bool __ret = false; while (1) { _M_has_sol = false; if (_M_states._M_match_queue.empty()) break; std::fill_n(_M_states._M_visited_states.get(), _M_nfa.size(), false); auto __old_queue = std::move(_M_states._M_match_queue); for (auto& __task : __old_queue) { _M_cur_results = std::move(__task.second); _M_dfs(__match_mode, __task.first); } if (__match_mode == _Match_mode::_Prefix) __ret |= _M_has_sol; if (_M_current == _M_end) break; ++_M_current; } if (__match_mode == _Match_mode::_Exact) __ret = _M_has_sol; _M_states._M_match_queue.clear(); return __ret; } template bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_lookahead(_StateIdT __next) { _ResultsVec __what(_M_cur_results); _Executor __sub(_M_current, _M_end, __what, _M_re, _M_flags); __sub._M_states._M_start = __next; if (__sub._M_search_from_first()) { for (size_t __i = 0; __i < __what.size(); __i++) if (__what[__i].matched) _M_cur_results[__i] = __what[__i]; return true; } return false; } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_rep_once_more(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; auto& __rep_count = _M_rep_count[__i]; if (__rep_count.second == 0 || __rep_count.first != _M_current) { auto __back = __rep_count; __rep_count.first = _M_current; __rep_count.second = 1; _M_dfs(__match_mode, __state._M_alt); __rep_count = __back; } else { if (__rep_count.second < 2) { __rep_count.second++; _M_dfs(__match_mode, __state._M_alt); __rep_count.second--; } } } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_repeat(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (!__state._M_neg) { _M_rep_once_more(__match_mode, __i); if (!__dfs_mode || !_M_has_sol) _M_dfs(__match_mode, __state._M_next); } else { if (__dfs_mode) { _M_dfs(__match_mode, __state._M_next); if (!_M_has_sol) _M_rep_once_more(__match_mode, __i); } else { if (!_M_has_sol) { _M_dfs(__match_mode, __state._M_next); if (!_M_has_sol) _M_rep_once_more(__match_mode, __i); } } } } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_subexpr_begin(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; auto& __res = _M_cur_results[__state._M_subexpr]; auto __back = __res.first; __res.first = _M_current; _M_dfs(__match_mode, __state._M_next); __res.first = __back; } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_subexpr_end(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; auto& __res = _M_cur_results[__state._M_subexpr]; auto __back = __res; __res.second = _M_current; __res.matched = true; _M_dfs(__match_mode, __state._M_next); __res = __back; } template inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_line_begin_assertion(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_at_begin()) _M_dfs(__match_mode, __state._M_next); } template inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_line_end_assertion(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_at_end()) _M_dfs(__match_mode, __state._M_next); } template inline void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_word_boundary(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_word_boundary() == !__state._M_neg) _M_dfs(__match_mode, __state._M_next); } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_subexpr_lookahead(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_lookahead(__state._M_alt) == !__state._M_neg) _M_dfs(__match_mode, __state._M_next); } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_match(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_current == _M_end) return; if (__dfs_mode) { if (__state._M_matches(*_M_current)) { ++_M_current; _M_dfs(__match_mode, __state._M_next); --_M_current; } } else if (__state._M_matches(*_M_current)) _M_states._M_queue(__state._M_next, _M_cur_results); } template struct _Backref_matcher { _Backref_matcher(bool __icase, const _TraitsT& __traits) : _M_traits(__traits) { } bool _M_apply(_BiIter __expected_begin, _BiIter __expected_end, _BiIter __actual_begin, _BiIter __actual_end) { return _M_traits.transform(__expected_begin, __expected_end) == _M_traits.transform(__actual_begin, __actual_end); } const _TraitsT& _M_traits; }; template struct _Backref_matcher<_BiIter, std::regex_traits<_CharT>> { using _TraitsT = std::regex_traits<_CharT>; _Backref_matcher(bool __icase, const _TraitsT& __traits) : _M_icase(__icase), _M_traits(__traits) { } bool _M_apply(_BiIter __expected_begin, _BiIter __expected_end, _BiIter __actual_begin, _BiIter __actual_end) { if (!_M_icase) return std::__equal4(__expected_begin, __expected_end, __actual_begin, __actual_end); typedef std::ctype<_CharT> __ctype_type; const auto& __fctyp = use_facet<__ctype_type>(_M_traits.getloc()); return std::__equal4(__expected_begin, __expected_end, __actual_begin, __actual_end, [this, &__fctyp](_CharT __lhs, _CharT __rhs) { return __fctyp.tolower(__lhs) == __fctyp.tolower(__rhs); }); } bool _M_icase; const _TraitsT& _M_traits; }; template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_backref(_Match_mode __match_mode, _StateIdT __i) { ; const auto& __state = _M_nfa[__i]; auto& __submatch = _M_cur_results[__state._M_backref_index]; if (!__submatch.matched) return; auto __last = _M_current; for (auto __tmp = __submatch.first; __last != _M_end && __tmp != __submatch.second; ++__tmp) ++__last; if (_Backref_matcher<_BiIter, _TraitsT>( _M_re.flags() & regex_constants::icase, _M_re._M_automaton->_M_traits)._M_apply( __submatch.first, __submatch.second, _M_current, __last)) { if (__last != _M_current) { auto __backup = _M_current; _M_current = __last; _M_dfs(__match_mode, __state._M_next); _M_current = __backup; } else _M_dfs(__match_mode, __state._M_next); } } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_accept(_Match_mode __match_mode, _StateIdT __i) { if (__dfs_mode) { ; if (__match_mode == _Match_mode::_Exact) _M_has_sol = _M_current == _M_end; else _M_has_sol = true; if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_null)) _M_has_sol = false; if (_M_has_sol) { if (_M_nfa._M_flags & regex_constants::ECMAScript) _M_results = _M_cur_results; else { ; if (*_M_states._M_get_sol_pos() == _BiIter() || std::distance(_M_begin, *_M_states._M_get_sol_pos()) < std::distance(_M_begin, _M_current)) { *_M_states._M_get_sol_pos() = _M_current; _M_results = _M_cur_results; } } } } else { if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_null)) return; if (__match_mode == _Match_mode::_Prefix || _M_current == _M_end) if (!_M_has_sol) { _M_has_sol = true; _M_results = _M_cur_results; } } } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_handle_alternative(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_nfa._M_flags & regex_constants::ECMAScript) { _M_dfs(__match_mode, __state._M_alt); if (!_M_has_sol) _M_dfs(__match_mode, __state._M_next); } else { _M_dfs(__match_mode, __state._M_alt); auto __has_sol = _M_has_sol; _M_has_sol = false; _M_dfs(__match_mode, __state._M_next); _M_has_sol |= __has_sol; } } template void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_dfs(_Match_mode __match_mode, _StateIdT __i) { if (_M_states._M_visited(__i)) return; switch (_M_nfa[__i]._M_opcode()) { case _S_opcode_repeat: _M_handle_repeat(__match_mode, __i); break; case _S_opcode_subexpr_begin: _M_handle_subexpr_begin(__match_mode, __i); break; case _S_opcode_subexpr_end: _M_handle_subexpr_end(__match_mode, __i); break; case _S_opcode_line_begin_assertion: _M_handle_line_begin_assertion(__match_mode, __i); break; case _S_opcode_line_end_assertion: _M_handle_line_end_assertion(__match_mode, __i); break; case _S_opcode_word_boundary: _M_handle_word_boundary(__match_mode, __i); break; case _S_opcode_subexpr_lookahead: _M_handle_subexpr_lookahead(__match_mode, __i); break; case _S_opcode_match: _M_handle_match(__match_mode, __i); break; case _S_opcode_backref: _M_handle_backref(__match_mode, __i); break; case _S_opcode_accept: _M_handle_accept(__match_mode, __i); break; case _S_opcode_alternative: _M_handle_alternative(__match_mode, __i); break; default: ; } } template bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: _M_word_boundary() const { if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_bow)) return false; if (_M_current == _M_end && (_M_flags & regex_constants::match_not_eow)) return false; bool __left_is_word = false; if (_M_current != _M_begin || (_M_flags & regex_constants::match_prev_avail)) { auto __prev = _M_current; if (_M_is_word(*std::prev(__prev))) __left_is_word = true; } bool __right_is_word = _M_current != _M_end && _M_is_word(*_M_current); return __left_is_word != __right_is_word; } } } # 259 "/usr/include/c++/10/bits/regex_executor.h" 2 3 # 64 "/usr/include/c++/10/regex" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { namespace pmr { template class polymorphic_allocator; template using match_results = std::match_results<_BidirectionalIterator, polymorphic_allocator< sub_match<_BidirectionalIterator>>>; using cmatch = match_results; using smatch = match_results<__gnu_cxx::__normal_iterator>; using wcmatch = match_results; using wsmatch = match_results<__gnu_cxx::__normal_iterator>; } } # 98 "all-std.cxx" 2 # 1 "/usr/include/c++/10/future" 1 3 # 32 "/usr/include/c++/10/future" 3 # 33 "/usr/include/c++/10/future" 3 # 1 "/usr/include/c++/10/mutex" 1 3 # 32 "/usr/include/c++/10/mutex" 3 # 33 "/usr/include/c++/10/mutex" 3 # 53 "/usr/include/c++/10/mutex" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 65 "/usr/include/c++/10/mutex" 3 class __recursive_mutex_base { protected: typedef __gthread_recursive_mutex_t __native_type; __recursive_mutex_base(const __recursive_mutex_base&) = delete; __recursive_mutex_base& operator=(const __recursive_mutex_base&) = delete; __native_type _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } }; __recursive_mutex_base() = default; # 89 "/usr/include/c++/10/mutex" 3 }; class recursive_mutex : private __recursive_mutex_base { public: typedef __native_type* native_handle_type; recursive_mutex() = default; ~recursive_mutex() = default; recursive_mutex(const recursive_mutex&) = delete; recursive_mutex& operator=(const recursive_mutex&) = delete; void lock() { int __e = __gthread_recursive_mutex_lock(&_M_mutex); if (__e) __throw_system_error(__e); } bool try_lock() noexcept { return !__gthread_recursive_mutex_trylock(&_M_mutex); } void unlock() { __gthread_recursive_mutex_unlock(&_M_mutex); } native_handle_type native_handle() noexcept { return &_M_mutex; } }; template class __timed_mutex_impl { protected: template bool _M_try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { using __clock = chrono::steady_clock; auto __rt = chrono::duration_cast<__clock::duration>(__rtime); if (ratio_greater<__clock::period, _Period>()) ++__rt; return _M_try_lock_until(__clock::now() + __rt); } template bool _M_try_lock_until(const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; return static_cast<_Derived*>(this)->_M_timedlock(__ts); } template bool _M_try_lock_until(const chrono::time_point& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); __gthread_time_t __ts = { static_cast(__s.time_since_epoch().count()), static_cast(__ns.count()) }; return static_cast<_Derived*>(this)->_M_clocklock(1, __ts); } template bool _M_try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { static_assert(chrono::is_clock_v<_Clock>); auto __now = _Clock::now(); do { auto __rtime = __atime - __now; if (_M_try_lock_for(__rtime)) return true; __now = _Clock::now(); } while (__atime > __now); return false; } }; class timed_mutex : private __mutex_base, public __timed_mutex_impl { public: typedef __native_type* native_handle_type; timed_mutex() = default; ~timed_mutex() = default; timed_mutex(const timed_mutex&) = delete; timed_mutex& operator=(const timed_mutex&) = delete; void lock() { int __e = __gthread_mutex_lock(&_M_mutex); if (__e) __throw_system_error(__e); } bool try_lock() noexcept { return !__gthread_mutex_trylock(&_M_mutex); } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { return _M_try_lock_for(__rtime); } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { return _M_try_lock_until(__atime); } void unlock() { __gthread_mutex_unlock(&_M_mutex); } native_handle_type native_handle() noexcept { return &_M_mutex; } private: friend class __timed_mutex_impl; bool _M_timedlock(const __gthread_time_t& __ts) { return !__gthread_mutex_timedlock(&_M_mutex, &__ts); } bool _M_clocklock(clockid_t clockid, const __gthread_time_t& __ts) { return !pthread_mutex_clocklock(&_M_mutex, clockid, &__ts); } }; class recursive_timed_mutex : private __recursive_mutex_base, public __timed_mutex_impl { public: typedef __native_type* native_handle_type; recursive_timed_mutex() = default; ~recursive_timed_mutex() = default; recursive_timed_mutex(const recursive_timed_mutex&) = delete; recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete; void lock() { int __e = __gthread_recursive_mutex_lock(&_M_mutex); if (__e) __throw_system_error(__e); } bool try_lock() noexcept { return !__gthread_recursive_mutex_trylock(&_M_mutex); } template bool try_lock_for(const chrono::duration<_Rep, _Period>& __rtime) { return _M_try_lock_for(__rtime); } template bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __atime) { return _M_try_lock_until(__atime); } void unlock() { __gthread_recursive_mutex_unlock(&_M_mutex); } native_handle_type native_handle() noexcept { return &_M_mutex; } private: friend class __timed_mutex_impl; bool _M_timedlock(const __gthread_time_t& __ts) { return !__gthread_recursive_mutex_timedlock(&_M_mutex, &__ts); } bool _M_clocklock(clockid_t clockid, const __gthread_time_t& __ts) { return !pthread_mutex_clocklock(&_M_mutex, clockid, &__ts); } }; # 513 "/usr/include/c++/10/mutex" 3 template inline unique_lock<_Lock> __try_to_lock(_Lock& __l) { return unique_lock<_Lock>{__l, try_to_lock}; } template struct __try_lock_impl { template static void __do_try_lock(tuple<_Lock&...>& __locks, int& __idx) { __idx = _Idx; auto __lock = std::__try_to_lock(std::get<_Idx>(__locks)); if (__lock.owns_lock()) { constexpr bool __cont = _Idx + 2 < sizeof...(_Lock); using __try_locker = __try_lock_impl<_Idx + 1, __cont>; __try_locker::__do_try_lock(__locks, __idx); if (__idx == -1) __lock.release(); } } }; template struct __try_lock_impl<_Idx, false> { template static void __do_try_lock(tuple<_Lock&...>& __locks, int& __idx) { __idx = _Idx; auto __lock = std::__try_to_lock(std::get<_Idx>(__locks)); if (__lock.owns_lock()) { __idx = -1; __lock.release(); } } }; # 566 "/usr/include/c++/10/mutex" 3 template int try_lock(_Lock1& __l1, _Lock2& __l2, _Lock3&... __l3) { int __idx; auto __locks = std::tie(__l1, __l2, __l3...); __try_lock_impl<0>::__do_try_lock(__locks, __idx); return __idx; } # 587 "/usr/include/c++/10/mutex" 3 template void lock(_L1& __l1, _L2& __l2, _L3&... __l3) { while (true) { using __try_locker = __try_lock_impl<0, sizeof...(_L3) != 0>; unique_lock<_L1> __first(__l1); int __idx; auto __locks = std::tie(__l2, __l3...); __try_locker::__do_try_lock(__locks, __idx); if (__idx == -1) { __first.release(); return; } } } # 613 "/usr/include/c++/10/mutex" 3 template class scoped_lock { public: explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m...)) { std::lock(__m...); } explicit scoped_lock(adopt_lock_t, _MutexTypes&... __m) noexcept : _M_devices(std::tie(__m...)) { } ~scoped_lock() { std::apply([](auto&... __m) { (__m.unlock(), ...); }, _M_devices); } scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; private: tuple<_MutexTypes&...> _M_devices; }; template<> class scoped_lock<> { public: explicit scoped_lock() = default; explicit scoped_lock(adopt_lock_t) noexcept { } ~scoped_lock() = default; scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; }; template class scoped_lock<_Mutex> { public: using mutex_type = _Mutex; explicit scoped_lock(mutex_type& __m) : _M_device(__m) { _M_device.lock(); } explicit scoped_lock(adopt_lock_t, mutex_type& __m) noexcept : _M_device(__m) { } ~scoped_lock() { _M_device.unlock(); } scoped_lock(const scoped_lock&) = delete; scoped_lock& operator=(const scoped_lock&) = delete; private: mutex_type& _M_device; }; struct once_flag { private: typedef __gthread_once_t __native_type; __native_type _M_once = 0; public: constexpr once_flag() noexcept = default; once_flag(const once_flag&) = delete; once_flag& operator=(const once_flag&) = delete; template friend void call_once(once_flag& __once, _Callable&& __f, _Args&&... __args); }; extern __thread void* __once_callable; extern __thread void (*__once_call)(); # 706 "/usr/include/c++/10/mutex" 3 extern "C" void __once_proxy(void); template void call_once(once_flag& __once, _Callable&& __f, _Args&&... __args) { auto __callable = [&] { std::__invoke(std::forward<_Callable>(__f), std::forward<_Args>(__args)...); }; __once_callable = std::__addressof(__callable); __once_call = []{ (*(decltype(__callable)*)__once_callable)(); }; int __e = __gthread_once(&__once._M_once, &__once_proxy); if (__e) __throw_system_error(__e); } } # 39 "/usr/include/c++/10/future" 2 3 # 1 "/usr/include/c++/10/thread" 1 3 # 32 "/usr/include/c++/10/thread" 3 # 33 "/usr/include/c++/10/thread" 3 # 53 "/usr/include/c++/10/thread" 3 # 1 "/usr/include/c++/10/cerrno" 1 3 # 39 "/usr/include/c++/10/cerrno" 3 # 40 "/usr/include/c++/10/cerrno" 3 # 54 "/usr/include/c++/10/thread" 2 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 73 "/usr/include/c++/10/thread" 3 class thread { public: struct _State { virtual ~_State(); virtual void _M_run() = 0; }; using _State_ptr = unique_ptr<_State>; typedef __gthread_t native_handle_type; class id { native_handle_type _M_thread; public: id() noexcept : _M_thread() { } explicit id(native_handle_type __id) : _M_thread(__id) { } private: friend class thread; friend class hash; friend bool operator==(id __x, id __y) noexcept; friend strong_ordering operator<=>(id __x, id __y) noexcept; template friend basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, id __id); }; private: id _M_id; template using __not_same = __not_, thread>>; public: thread() noexcept = default; template>> explicit thread(_Callable&& __f, _Args&&... __args) { static_assert( __is_invocable::type, typename decay<_Args>::type...>::value, "std::thread arguments must be invocable after conversion to rvalues" ); auto __depend = reinterpret_cast(&pthread_create); using _Invoker_type = _Invoker<__decayed_tuple<_Callable, _Args...>>; _M_start_thread(_S_make_state<_Invoker_type>( std::forward<_Callable>(__f), std::forward<_Args>(__args)...), __depend); } ~thread() { if (joinable()) std::terminate(); } thread(const thread&) = delete; thread(thread&& __t) noexcept { swap(__t); } thread& operator=(const thread&) = delete; thread& operator=(thread&& __t) noexcept { if (joinable()) std::terminate(); swap(__t); return *this; } void swap(thread& __t) noexcept { std::swap(_M_id, __t._M_id); } bool joinable() const noexcept { return !(_M_id == id()); } void join(); void detach(); id get_id() const noexcept { return _M_id; } native_handle_type native_handle() { return _M_id._M_thread; } static unsigned int hardware_concurrency() noexcept; private: template struct _State_impl : public _State { _Callable _M_func; template _State_impl(_Args&&... __args) : _M_func{{std::forward<_Args>(__args)...}} { } void _M_run() { _M_func(); } }; void _M_start_thread(_State_ptr, void (*)()); template static _State_ptr _S_make_state(_Args&&... __args) { using _Impl = _State_impl<_Callable>; return _State_ptr{new _Impl{std::forward<_Args>(__args)...}}; } # 247 "/usr/include/c++/10/thread" 3 private: template struct _Invoker { _Tuple _M_t; template struct __result; template struct __result> : __invoke_result<_Fn, _Args...> { }; template typename __result<_Tuple>::type _M_invoke(_Index_tuple<_Ind...>) { return std::__invoke(std::get<_Ind>(std::move(_M_t))...); } typename __result<_Tuple>::type operator()() { using _Indices = typename _Build_index_tuple::value>::__type; return _M_invoke(_Indices()); } }; template using __decayed_tuple = tuple::type...>; public: template static _Invoker<__decayed_tuple<_Callable, _Args...>> __make_invoker(_Callable&& __callable, _Args&&... __args) { return { __decayed_tuple<_Callable, _Args...>{ std::forward<_Callable>(__callable), std::forward<_Args>(__args)... } }; } }; inline void swap(thread& __x, thread& __y) noexcept { __x.swap(__y); } inline bool operator==(thread::id __x, thread::id __y) noexcept { return __x._M_thread == __y._M_thread; } inline strong_ordering operator<=>(thread::id __x, thread::id __y) noexcept { return __x._M_thread <=> __y._M_thread; } # 337 "/usr/include/c++/10/thread" 3 template<> struct hash : public __hash_base { size_t operator()(const thread::id& __id) const noexcept { return std::_Hash_impl::hash(__id._M_thread); } }; template inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id) { if (__id == thread::id()) return __out << "thread::id of a non-executing thread"; else return __out << __id._M_thread; } namespace this_thread { inline thread::id get_id() noexcept { return thread::id(pthread_self()); } inline void yield() noexcept { __gthread_yield(); } void __sleep_for(chrono::seconds, chrono::nanoseconds); template inline void sleep_for(const chrono::duration<_Rep, _Period>& __rtime) { if (__rtime <= __rtime.zero()) return; auto __s = chrono::duration_cast(__rtime); auto __ns = chrono::duration_cast(__rtime - __s); __gthread_time_t __ts = { static_cast(__s.count()), static_cast(__ns.count()) }; while (::nanosleep(&__ts, &__ts) == -1 && (*__errno_location ()) == 4) { } } template inline void sleep_until(const chrono::time_point<_Clock, _Duration>& __atime) { static_assert(chrono::is_clock_v<_Clock>); auto __now = _Clock::now(); if (_Clock::is_steady) { if (__now < __atime) sleep_for(__atime - __now); return; } while (__now < __atime) { sleep_for(__atime - __now); __now = _Clock::now(); } } } class jthread { public: using id = thread::id; using native_handle_type = thread::native_handle_type; jthread() noexcept : _M_stop_source{nostopstate} { } template, jthread>>> explicit jthread(_Callable&& __f, _Args&&... __args) : _M_thread{_S_create(_M_stop_source, std::forward<_Callable>(__f), std::forward<_Args>(__args)...)} { } jthread(const jthread&) = delete; jthread(jthread&&) noexcept = default; ~jthread() { if (joinable()) { request_stop(); join(); } } jthread& operator=(const jthread&) = delete; jthread& operator=(jthread&& __other) noexcept { std::jthread(std::move(__other)).swap(*this); return *this; } void swap(jthread& __other) noexcept { std::swap(_M_stop_source, __other._M_stop_source); std::swap(_M_thread, __other._M_thread); } [[nodiscard]] bool joinable() const noexcept { return _M_thread.joinable(); } void join() { _M_thread.join(); } void detach() { _M_thread.detach(); } [[nodiscard]] id get_id() const noexcept { return _M_thread.get_id(); } [[nodiscard]] native_handle_type native_handle() { return _M_thread.native_handle(); } [[nodiscard]] static unsigned hardware_concurrency() noexcept { return thread::hardware_concurrency(); } [[nodiscard]] stop_source get_stop_source() noexcept { return _M_stop_source; } [[nodiscard]] stop_token get_stop_token() const noexcept { return _M_stop_source.get_token(); } bool request_stop() noexcept { return _M_stop_source.request_stop(); } friend void swap(jthread& __lhs, jthread& __rhs) noexcept { __lhs.swap(__rhs); } private: template static thread _S_create(stop_source& __ssrc, _Callable&& __f, _Args&&... __args) { if constexpr(is_invocable_v, stop_token, decay_t<_Args>...>) return thread{std::forward<_Callable>(__f), __ssrc.get_token(), std::forward<_Args>(__args)...}; else { static_assert(is_invocable_v, decay_t<_Args>...>, "std::thread arguments must be invocable after" " conversion to rvalues"); return thread{std::forward<_Callable>(__f), std::forward<_Args>(__args)...}; } } stop_source _M_stop_source; thread _M_thread; }; } # 40 "/usr/include/c++/10/future" 2 3 # 1 "/usr/include/c++/10/bits/atomic_futex.h" 1 3 # 33 "/usr/include/c++/10/bits/atomic_futex.h" 3 # 34 "/usr/include/c++/10/bits/atomic_futex.h" 3 # 47 "/usr/include/c++/10/bits/atomic_futex.h" 3 namespace std __attribute__ ((__visibility__ ("default"))) { struct __atomic_futex_unsigned_base { bool _M_futex_wait_until(unsigned *__addr, unsigned __val, bool __has_timeout, chrono::seconds __s, chrono::nanoseconds __ns); static void _M_futex_notify_all(unsigned* __addr); }; template class __atomic_futex_unsigned : __atomic_futex_unsigned_base { typedef chrono::system_clock __clock_t; atomic _M_data; public: explicit __atomic_futex_unsigned(unsigned __data) : _M_data(__data) { } inline __attribute__((__always_inline__)) unsigned _M_load(memory_order __mo) { return _M_data.load(__mo) & ~_Waiter_bit; } private: unsigned _M_load_and_test_until(unsigned __assumed, unsigned __operand, bool __equal, memory_order __mo, bool __has_timeout, chrono::seconds __s, chrono::nanoseconds __ns) { for (;;) { _M_data.fetch_or(_Waiter_bit, memory_order_relaxed); bool __ret = _M_futex_wait_until((unsigned*)(void*)&_M_data, __assumed | _Waiter_bit, __has_timeout, __s, __ns); __assumed = _M_load(__mo); if (!__ret || ((__operand == __assumed) == __equal)) return __assumed; } } unsigned _M_load_and_test(unsigned __assumed, unsigned __operand, bool __equal, memory_order __mo) { return _M_load_and_test_until(__assumed, __operand, __equal, __mo, false, {}, {}); } template unsigned _M_load_and_test_until_impl(unsigned __assumed, unsigned __operand, bool __equal, memory_order __mo, const chrono::time_point<__clock_t, _Dur>& __atime) { auto __s = chrono::time_point_cast(__atime); auto __ns = chrono::duration_cast(__atime - __s); return _M_load_and_test_until(__assumed, __operand, __equal, __mo, true, __s.time_since_epoch(), __ns); } public: inline __attribute__((__always_inline__)) unsigned _M_load_when_not_equal(unsigned __val, memory_order __mo) { unsigned __i = _M_load(__mo); if ((__i & ~_Waiter_bit) != __val) return (__i & ~_Waiter_bit); return _M_load_and_test(__i, __val, false, __mo); } inline __attribute__((__always_inline__)) void _M_load_when_equal(unsigned __val, memory_order __mo) { unsigned __i = _M_load(__mo); if ((__i & ~_Waiter_bit) == __val) return; _M_load_and_test(__i, __val, true, __mo); } template inline __attribute__((__always_inline__)) bool _M_load_when_equal_for(unsigned __val, memory_order __mo, const chrono::duration<_Rep, _Period>& __rtime) { return _M_load_when_equal_until(__val, __mo, __clock_t::now() + __rtime); } template inline __attribute__((__always_inline__)) bool _M_load_when_equal_until(unsigned __val, memory_order __mo, const chrono::time_point<_Clock, _Duration>& __atime) { const typename _Clock::time_point __c_entry = _Clock::now(); const __clock_t::time_point __s_entry = __clock_t::now(); const auto __delta = __atime - __c_entry; const auto __s_atime = __s_entry + __delta; return _M_load_when_equal_until(__val, __mo, __s_atime); } template inline __attribute__((__always_inline__)) bool _M_load_when_equal_until(unsigned __val, memory_order __mo, const chrono::time_point<__clock_t, _Duration>& __atime) { unsigned __i = _M_load(__mo); if ((__i & ~_Waiter_bit) == __val) return true; __i = _M_load_and_test_until_impl(__i, __val, true, __mo, __atime); return (__i & ~_Waiter_bit) == __val; } inline __attribute__((__always_inline__)) void _M_store_notify_all(unsigned __val, memory_order __mo) { unsigned* __futex = (unsigned *)(void *)&_M_data; if (_M_data.exchange(__val, __mo) & _Waiter_bit) _M_futex_notify_all(__futex); } }; # 287 "/usr/include/c++/10/bits/atomic_futex.h" 3 } # 44 "/usr/include/c++/10/future" 2 3 # 53 "/usr/include/c++/10/future" 3 namespace std __attribute__ ((__visibility__ ("default"))) { # 66 "/usr/include/c++/10/future" 3 enum class future_errc { future_already_retrieved = 1, promise_already_satisfied, no_state, broken_promise }; template<> struct is_error_code_enum : public true_type { }; const error_category& future_category() noexcept; inline error_code make_error_code(future_errc __errc) noexcept { return error_code(static_cast(__errc), future_category()); } inline error_condition make_error_condition(future_errc __errc) noexcept { return error_condition(static_cast(__errc), future_category()); } class future_error : public logic_error { public: explicit future_error(future_errc __errc) : future_error(std::make_error_code(__errc)) { } virtual ~future_error() noexcept; virtual const char* what() const noexcept; const error_code& code() const noexcept { return _M_code; } private: explicit future_error(error_code __ec) : logic_error("std::future_error: " + __ec.message()), _M_code(__ec) { } friend void __throw_future_error(int); error_code _M_code; }; template class future; template class shared_future; template class packaged_task; template class promise; enum class launch { async = 1, deferred = 2 }; constexpr launch operator&(launch __x, launch __y) { return static_cast( static_cast(__x) & static_cast(__y)); } constexpr launch operator|(launch __x, launch __y) { return static_cast( static_cast(__x) | static_cast(__y)); } constexpr launch operator^(launch __x, launch __y) { return static_cast( static_cast(__x) ^ static_cast(__y)); } constexpr launch operator~(launch __x) { return static_cast(~static_cast(__x)); } inline launch& operator&=(launch& __x, launch __y) { return __x = __x & __y; } inline launch& operator|=(launch& __x, launch __y) { return __x = __x | __y; } inline launch& operator^=(launch& __x, launch __y) { return __x = __x ^ __y; } enum class future_status { ready, timeout, deferred }; template using __async_result_of = typename __invoke_result< typename decay<_Fn>::type, typename decay<_Args>::type...>::type; template future<__async_result_of<_Fn, _Args...>> async(launch __policy, _Fn&& __fn, _Args&&... __args); template future<__async_result_of<_Fn, _Args...>> async(_Fn&& __fn, _Args&&... __args); struct __future_base { struct _Result_base { exception_ptr _M_error; _Result_base(const _Result_base&) = delete; _Result_base& operator=(const _Result_base&) = delete; virtual void _M_destroy() = 0; struct _Deleter { void operator()(_Result_base* __fr) const { __fr->_M_destroy(); } }; protected: _Result_base(); virtual ~_Result_base(); }; template using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>; template struct _Result : _Result_base { private: __gnu_cxx::__aligned_buffer<_Res> _M_storage; bool _M_initialized; public: typedef _Res result_type; _Result() noexcept : _M_initialized() { } ~_Result() { if (_M_initialized) _M_value().~_Res(); } _Res& _M_value() noexcept { return *_M_storage._M_ptr(); } void _M_set(const _Res& __res) { ::new (_M_storage._M_addr()) _Res(__res); _M_initialized = true; } void _M_set(_Res&& __res) { ::new (_M_storage._M_addr()) _Res(std::move(__res)); _M_initialized = true; } private: void _M_destroy() { delete this; } }; template struct _Result_alloc final : _Result<_Res>, _Alloc { using __allocator_type = __alloc_rebind<_Alloc, _Result_alloc>; explicit _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a) { } private: void _M_destroy() { __allocator_type __a(*this); __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; this->~_Result_alloc(); } }; template static _Ptr<_Result_alloc<_Res, _Allocator>> _S_allocate_result(const _Allocator& __a) { using __result_type = _Result_alloc<_Res, _Allocator>; typename __result_type::__allocator_type __a2(__a); auto __guard = std::__allocate_guarded(__a2); __result_type* __p = ::new((void*)__guard.get()) __result_type{__a}; __guard = nullptr; return _Ptr<__result_type>(__p); } template static _Ptr<_Result<_Res>> _S_allocate_result(const std::allocator<_Tp>& __a) { return _Ptr<_Result<_Res>>(new _Result<_Res>); } class _State_baseV2 { typedef _Ptr<_Result_base> _Ptr_type; enum _Status : unsigned { __not_ready, __ready }; _Ptr_type _M_result; __atomic_futex_unsigned<> _M_status; atomic_flag _M_retrieved = { 0 }; once_flag _M_once; public: _State_baseV2() noexcept : _M_result(), _M_status(_Status::__not_ready) { } _State_baseV2(const _State_baseV2&) = delete; _State_baseV2& operator=(const _State_baseV2&) = delete; virtual ~_State_baseV2() = default; _Result_base& wait() { _M_complete_async(); _M_status._M_load_when_equal(_Status::__ready, memory_order_acquire); return *_M_result; } template future_status wait_for(const chrono::duration<_Rep, _Period>& __rel) { if (_M_status._M_load(memory_order_acquire) == _Status::__ready) return future_status::ready; if (_M_is_deferred_future()) return future_status::deferred; if (__rel > __rel.zero() && _M_status._M_load_when_equal_for(_Status::__ready, memory_order_acquire, __rel)) { # 368 "/usr/include/c++/10/future" 3 _M_complete_async(); return future_status::ready; } return future_status::timeout; } template future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs) { static_assert(chrono::is_clock_v<_Clock>); if (_M_status._M_load(memory_order_acquire) == _Status::__ready) return future_status::ready; if (_M_is_deferred_future()) return future_status::deferred; if (_M_status._M_load_when_equal_until(_Status::__ready, memory_order_acquire, __abs)) { _M_complete_async(); return future_status::ready; } return future_status::timeout; } void _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false) { bool __did_set = false; call_once(_M_once, &_State_baseV2::_M_do_set, this, std::__addressof(__res), std::__addressof(__did_set)); if (__did_set) _M_status._M_store_notify_all(_Status::__ready, memory_order_release); else if (!__ignore_failure) __throw_future_error(int(future_errc::promise_already_satisfied)); } void _M_set_delayed_result(function<_Ptr_type()> __res, weak_ptr<_State_baseV2> __self) { bool __did_set = false; unique_ptr<_Make_ready> __mr{new _Make_ready}; call_once(_M_once, &_State_baseV2::_M_do_set, this, std::__addressof(__res), std::__addressof(__did_set)); if (!__did_set) __throw_future_error(int(future_errc::promise_already_satisfied)); __mr->_M_shared_state = std::move(__self); __mr->_M_set(); __mr.release(); } void _M_break_promise(_Ptr_type __res) { if (static_cast(__res)) { __res->_M_error = make_exception_ptr(future_error(future_errc::broken_promise)); _M_result.swap(__res); _M_status._M_store_notify_all(_Status::__ready, memory_order_release); } } void _M_set_retrieved_flag() { if (_M_retrieved.test_and_set()) __throw_future_error(int(future_errc::future_already_retrieved)); } template struct _Setter; template struct _Setter<_Res, _Arg&> { static_assert(is_same<_Res, _Arg&>::value || is_same::value, "Invalid specialisation"); typename promise<_Res>::_Ptr_type operator()() const { _M_promise->_M_storage->_M_set(*_M_arg); return std::move(_M_promise->_M_storage); } promise<_Res>* _M_promise; _Arg* _M_arg; }; template struct _Setter<_Res, _Res&&> { typename promise<_Res>::_Ptr_type operator()() const { _M_promise->_M_storage->_M_set(std::move(*_M_arg)); return std::move(_M_promise->_M_storage); } promise<_Res>* _M_promise; _Res* _M_arg; }; template struct _Setter<_Res, void> { static_assert(is_void<_Res>::value, "Only used for promise"); typename promise<_Res>::_Ptr_type operator()() const { return std::move(_M_promise->_M_storage); } promise<_Res>* _M_promise; }; struct __exception_ptr_tag { }; template struct _Setter<_Res, __exception_ptr_tag> { typename promise<_Res>::_Ptr_type operator()() const { _M_promise->_M_storage->_M_error = *_M_ex; return std::move(_M_promise->_M_storage); } promise<_Res>* _M_promise; exception_ptr* _M_ex; }; template static _Setter<_Res, _Arg&&> __setter(promise<_Res>* __prom, _Arg&& __arg) { _S_check(__prom->_M_future); return _Setter<_Res, _Arg&&>{ __prom, std::__addressof(__arg) }; } template static _Setter<_Res, __exception_ptr_tag> __setter(exception_ptr& __ex, promise<_Res>* __prom) { _S_check(__prom->_M_future); return _Setter<_Res, __exception_ptr_tag>{ __prom, &__ex }; } template static _Setter<_Res, void> __setter(promise<_Res>* __prom) { _S_check(__prom->_M_future); return _Setter<_Res, void>{ __prom }; } template static void _S_check(const shared_ptr<_Tp>& __p) { if (!static_cast(__p)) __throw_future_error((int)future_errc::no_state); } private: void _M_do_set(function<_Ptr_type()>* __f, bool* __did_set) { _Ptr_type __res = (*__f)(); *__did_set = true; _M_result.swap(__res); } virtual void _M_complete_async() { } virtual bool _M_is_deferred_future() const { return false; } struct _Make_ready final : __at_thread_exit_elt { weak_ptr<_State_baseV2> _M_shared_state; static void _S_run(void*); void _M_set(); }; }; using _State_base = _State_baseV2; class _Async_state_commonV2; template()())> class _Deferred_state; template()())> class _Async_state_impl; template class _Task_state_base; template class _Task_state; template static std::shared_ptr<_State_base> _S_make_deferred_state(_BoundFn&& __fn); template static std::shared_ptr<_State_base> _S_make_async_state(_BoundFn&& __fn); template struct _Task_setter; template static _Task_setter<_Res_ptr, _BoundFn> _S_task_setter(_Res_ptr& __ptr, _BoundFn& __call) { return { std::__addressof(__ptr), std::__addressof(__call) }; } }; template struct __future_base::_Result<_Res&> : __future_base::_Result_base { typedef _Res& result_type; _Result() noexcept : _M_value_ptr() { } void _M_set(_Res& __res) noexcept { _M_value_ptr = std::addressof(__res); } _Res& _M_get() noexcept { return *_M_value_ptr; } private: _Res* _M_value_ptr; void _M_destroy() { delete this; } }; template<> struct __future_base::_Result : __future_base::_Result_base { typedef void result_type; private: void _M_destroy() { delete this; } }; template struct __is_location_invariant <__future_base::_State_base::_Setter<_Res, _Arg>> : true_type { }; template struct __is_location_invariant <__future_base::_Task_setter<_Res_ptr, _Fn, _Res>> : true_type { }; template class __basic_future : public __future_base { protected: typedef shared_ptr<_State_base> __state_type; typedef __future_base::_Result<_Res>& __result_type; private: __state_type _M_state; public: __basic_future(const __basic_future&) = delete; __basic_future& operator=(const __basic_future&) = delete; bool valid() const noexcept { return static_cast(_M_state); } void wait() const { _State_base::_S_check(_M_state); _M_state->wait(); } template future_status wait_for(const chrono::duration<_Rep, _Period>& __rel) const { _State_base::_S_check(_M_state); return _M_state->wait_for(__rel); } template future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const { _State_base::_S_check(_M_state); return _M_state->wait_until(__abs); } protected: __result_type _M_get_result() const { _State_base::_S_check(_M_state); _Result_base& __res = _M_state->wait(); if (!(__res._M_error == 0)) rethrow_exception(__res._M_error); return static_cast<__result_type>(__res); } void _M_swap(__basic_future& __that) noexcept { _M_state.swap(__that._M_state); } explicit __basic_future(const __state_type& __state) : _M_state(__state) { _State_base::_S_check(_M_state); _M_state->_M_set_retrieved_flag(); } explicit __basic_future(const shared_future<_Res>&) noexcept; explicit __basic_future(shared_future<_Res>&&) noexcept; explicit __basic_future(future<_Res>&&) noexcept; constexpr __basic_future() noexcept : _M_state() { } struct _Reset { explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { } ~_Reset() { _M_fut._M_state.reset(); } __basic_future& _M_fut; }; }; template class future : public __basic_future<_Res> { friend class promise<_Res>; template friend class packaged_task; template friend future<__async_result_of<_Fn, _Args...>> async(launch, _Fn&&, _Args&&...); typedef __basic_future<_Res> _Base_type; typedef typename _Base_type::__state_type __state_type; explicit future(const __state_type& __state) : _Base_type(__state) { } public: constexpr future() noexcept : _Base_type() { } future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } future(const future&) = delete; future& operator=(const future&) = delete; future& operator=(future&& __fut) noexcept { future(std::move(__fut))._M_swap(*this); return *this; } _Res get() { typename _Base_type::_Reset __reset(*this); return std::move(this->_M_get_result()._M_value()); } shared_future<_Res> share() noexcept; }; template class future<_Res&> : public __basic_future<_Res&> { friend class promise<_Res&>; template friend class packaged_task; template friend future<__async_result_of<_Fn, _Args...>> async(launch, _Fn&&, _Args&&...); typedef __basic_future<_Res&> _Base_type; typedef typename _Base_type::__state_type __state_type; explicit future(const __state_type& __state) : _Base_type(__state) { } public: constexpr future() noexcept : _Base_type() { } future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } future(const future&) = delete; future& operator=(const future&) = delete; future& operator=(future&& __fut) noexcept { future(std::move(__fut))._M_swap(*this); return *this; } _Res& get() { typename _Base_type::_Reset __reset(*this); return this->_M_get_result()._M_get(); } shared_future<_Res&> share() noexcept; }; template<> class future : public __basic_future { friend class promise; template friend class packaged_task; template friend future<__async_result_of<_Fn, _Args...>> async(launch, _Fn&&, _Args&&...); typedef __basic_future _Base_type; typedef typename _Base_type::__state_type __state_type; explicit future(const __state_type& __state) : _Base_type(__state) { } public: constexpr future() noexcept : _Base_type() { } future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } future(const future&) = delete; future& operator=(const future&) = delete; future& operator=(future&& __fut) noexcept { future(std::move(__fut))._M_swap(*this); return *this; } void get() { typename _Base_type::_Reset __reset(*this); this->_M_get_result(); } shared_future share() noexcept; }; template class shared_future : public __basic_future<_Res> { typedef __basic_future<_Res> _Base_type; public: constexpr shared_future() noexcept : _Base_type() { } shared_future(const shared_future& __sf) noexcept : _Base_type(__sf) { } shared_future(future<_Res>&& __uf) noexcept : _Base_type(std::move(__uf)) { } shared_future(shared_future&& __sf) noexcept : _Base_type(std::move(__sf)) { } shared_future& operator=(const shared_future& __sf) noexcept { shared_future(__sf)._M_swap(*this); return *this; } shared_future& operator=(shared_future&& __sf) noexcept { shared_future(std::move(__sf))._M_swap(*this); return *this; } const _Res& get() const { return this->_M_get_result()._M_value(); } }; template class shared_future<_Res&> : public __basic_future<_Res&> { typedef __basic_future<_Res&> _Base_type; public: constexpr shared_future() noexcept : _Base_type() { } shared_future(const shared_future& __sf) : _Base_type(__sf) { } shared_future(future<_Res&>&& __uf) noexcept : _Base_type(std::move(__uf)) { } shared_future(shared_future&& __sf) noexcept : _Base_type(std::move(__sf)) { } shared_future& operator=(const shared_future& __sf) { shared_future(__sf)._M_swap(*this); return *this; } shared_future& operator=(shared_future&& __sf) noexcept { shared_future(std::move(__sf))._M_swap(*this); return *this; } _Res& get() const { return this->_M_get_result()._M_get(); } }; template<> class shared_future : public __basic_future { typedef __basic_future _Base_type; public: constexpr shared_future() noexcept : _Base_type() { } shared_future(const shared_future& __sf) : _Base_type(__sf) { } shared_future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { } shared_future(shared_future&& __sf) noexcept : _Base_type(std::move(__sf)) { } shared_future& operator=(const shared_future& __sf) { shared_future(__sf)._M_swap(*this); return *this; } shared_future& operator=(shared_future&& __sf) noexcept { shared_future(std::move(__sf))._M_swap(*this); return *this; } void get() const { this->_M_get_result(); } }; template inline __basic_future<_Res>:: __basic_future(const shared_future<_Res>& __sf) noexcept : _M_state(__sf._M_state) { } template inline __basic_future<_Res>:: __basic_future(shared_future<_Res>&& __sf) noexcept : _M_state(std::move(__sf._M_state)) { } template inline __basic_future<_Res>:: __basic_future(future<_Res>&& __uf) noexcept : _M_state(std::move(__uf._M_state)) { } template inline shared_future<_Res> future<_Res>::share() noexcept { return shared_future<_Res>(std::move(*this)); } template inline shared_future<_Res&> future<_Res&>::share() noexcept { return shared_future<_Res&>(std::move(*this)); } inline shared_future future::share() noexcept { return shared_future(std::move(*this)); } template class promise { typedef __future_base::_State_base _State; typedef __future_base::_Result<_Res> _Res_type; typedef __future_base::_Ptr<_Res_type> _Ptr_type; template friend class _State::_Setter; friend _State; shared_ptr<_State> _M_future; _Ptr_type _M_storage; public: promise() : _M_future(std::make_shared<_State>()), _M_storage(new _Res_type()) { } promise(promise&& __rhs) noexcept : _M_future(std::move(__rhs._M_future)), _M_storage(std::move(__rhs._M_storage)) { } template promise(allocator_arg_t, const _Allocator& __a) : _M_future(std::allocate_shared<_State>(__a)), _M_storage(__future_base::_S_allocate_result<_Res>(__a)) { } template promise(allocator_arg_t, const _Allocator&, promise&& __rhs) : _M_future(std::move(__rhs._M_future)), _M_storage(std::move(__rhs._M_storage)) { } promise(const promise&) = delete; ~promise() { if (static_cast(_M_future) && !_M_future.unique()) _M_future->_M_break_promise(std::move(_M_storage)); } promise& operator=(promise&& __rhs) noexcept { promise(std::move(__rhs)).swap(*this); return *this; } promise& operator=(const promise&) = delete; void swap(promise& __rhs) noexcept { _M_future.swap(__rhs._M_future); _M_storage.swap(__rhs._M_storage); } future<_Res> get_future() { return future<_Res>(_M_future); } void set_value(const _Res& __r) { _M_future->_M_set_result(_State::__setter(this, __r)); } void set_value(_Res&& __r) { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); } void set_exception(exception_ptr __p) { _M_future->_M_set_result(_State::__setter(__p, this)); } void set_value_at_thread_exit(const _Res& __r) { _M_future->_M_set_delayed_result(_State::__setter(this, __r), _M_future); } void set_value_at_thread_exit(_Res&& __r) { _M_future->_M_set_delayed_result( _State::__setter(this, std::move(__r)), _M_future); } void set_exception_at_thread_exit(exception_ptr __p) { _M_future->_M_set_delayed_result(_State::__setter(__p, this), _M_future); } }; template inline void swap(promise<_Res>& __x, promise<_Res>& __y) noexcept { __x.swap(__y); } template struct uses_allocator, _Alloc> : public true_type { }; template class promise<_Res&> { typedef __future_base::_State_base _State; typedef __future_base::_Result<_Res&> _Res_type; typedef __future_base::_Ptr<_Res_type> _Ptr_type; template friend class _State::_Setter; friend _State; shared_ptr<_State> _M_future; _Ptr_type _M_storage; public: promise() : _M_future(std::make_shared<_State>()), _M_storage(new _Res_type()) { } promise(promise&& __rhs) noexcept : _M_future(std::move(__rhs._M_future)), _M_storage(std::move(__rhs._M_storage)) { } template promise(allocator_arg_t, const _Allocator& __a) : _M_future(std::allocate_shared<_State>(__a)), _M_storage(__future_base::_S_allocate_result<_Res&>(__a)) { } template promise(allocator_arg_t, const _Allocator&, promise&& __rhs) : _M_future(std::move(__rhs._M_future)), _M_storage(std::move(__rhs._M_storage)) { } promise(const promise&) = delete; ~promise() { if (static_cast(_M_future) && !_M_future.unique()) _M_future->_M_break_promise(std::move(_M_storage)); } promise& operator=(promise&& __rhs) noexcept { promise(std::move(__rhs)).swap(*this); return *this; } promise& operator=(const promise&) = delete; void swap(promise& __rhs) noexcept { _M_future.swap(__rhs._M_future); _M_storage.swap(__rhs._M_storage); } future<_Res&> get_future() { return future<_Res&>(_M_future); } void set_value(_Res& __r) { _M_future->_M_set_result(_State::__setter(this, __r)); } void set_exception(exception_ptr __p) { _M_future->_M_set_result(_State::__setter(__p, this)); } void set_value_at_thread_exit(_Res& __r) { _M_future->_M_set_delayed_result(_State::__setter(this, __r), _M_future); } void set_exception_at_thread_exit(exception_ptr __p) { _M_future->_M_set_delayed_result(_State::__setter(__p, this), _M_future); } }; template<> class promise { typedef __future_base::_State_base _State; typedef __future_base::_Result _Res_type; typedef __future_base::_Ptr<_Res_type> _Ptr_type; template friend class _State::_Setter; friend _State; shared_ptr<_State> _M_future; _Ptr_type _M_storage; public: promise() : _M_future(std::make_shared<_State>()), _M_storage(new _Res_type()) { } promise(promise&& __rhs) noexcept : _M_future(std::move(__rhs._M_future)), _M_storage(std::move(__rhs._M_storage)) { } template promise(allocator_arg_t, const _Allocator& __a) : _M_future(std::allocate_shared<_State>(__a)), _M_storage(__future_base::_S_allocate_result(__a)) { } template promise(allocator_arg_t, const _Allocator&, promise&& __rhs) : _M_future(std::move(__rhs._M_future)), _M_storage(std::move(__rhs._M_storage)) { } promise(const promise&) = delete; ~promise() { if (static_cast(_M_future) && !_M_future.unique()) _M_future->_M_break_promise(std::move(_M_storage)); } promise& operator=(promise&& __rhs) noexcept { promise(std::move(__rhs)).swap(*this); return *this; } promise& operator=(const promise&) = delete; void swap(promise& __rhs) noexcept { _M_future.swap(__rhs._M_future); _M_storage.swap(__rhs._M_storage); } future get_future() { return future(_M_future); } void set_value() { _M_future->_M_set_result(_State::__setter(this)); } void set_exception(exception_ptr __p) { _M_future->_M_set_result(_State::__setter(__p, this)); } void set_value_at_thread_exit() { _M_future->_M_set_delayed_result(_State::__setter(this), _M_future); } void set_exception_at_thread_exit(exception_ptr __p) { _M_future->_M_set_delayed_result(_State::__setter(__p, this), _M_future); } }; template struct __future_base::_Task_setter { _Ptr_type operator()() const { try { (*_M_result)->_M_set((*_M_fn)()); } catch(const __cxxabiv1::__forced_unwind&) { throw; } catch(...) { (*_M_result)->_M_error = current_exception(); } return std::move(*_M_result); } _Ptr_type* _M_result; _Fn* _M_fn; }; template struct __future_base::_Task_setter<_Ptr_type, _Fn, void> { _Ptr_type operator()() const { try { (*_M_fn)(); } catch(const __cxxabiv1::__forced_unwind&) { throw; } catch(...) { (*_M_result)->_M_error = current_exception(); } return std::move(*_M_result); } _Ptr_type* _M_result; _Fn* _M_fn; }; template struct __future_base::_Task_state_base<_Res(_Args...)> : __future_base::_State_base { typedef _Res _Res_type; template _Task_state_base(const _Alloc& __a) : _M_result(_S_allocate_result<_Res>(__a)) { } virtual void _M_run(_Args&&... __args) = 0; virtual void _M_run_delayed(_Args&&... __args, weak_ptr<_State_base>) = 0; virtual shared_ptr<_Task_state_base> _M_reset() = 0; typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; _Ptr_type _M_result; }; template struct __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)> final : __future_base::_Task_state_base<_Res(_Args...)> { template _Task_state(_Fn2&& __fn, const _Alloc& __a) : _Task_state_base<_Res(_Args...)>(__a), _M_impl(std::forward<_Fn2>(__fn), __a) { } private: virtual void _M_run(_Args&&... __args) { auto __boundfn = [&] () -> _Res { return std::__invoke_r<_Res>(_M_impl._M_fn, std::forward<_Args>(__args)...); }; this->_M_set_result(_S_task_setter(this->_M_result, __boundfn)); } virtual void _M_run_delayed(_Args&&... __args, weak_ptr<_State_base> __self) { auto __boundfn = [&] () -> _Res { return std::__invoke_r<_Res>(_M_impl._M_fn, std::forward<_Args>(__args)...); }; this->_M_set_delayed_result(_S_task_setter(this->_M_result, __boundfn), std::move(__self)); } virtual shared_ptr<_Task_state_base<_Res(_Args...)>> _M_reset(); struct _Impl : _Alloc { template _Impl(_Fn2&& __fn, const _Alloc& __a) : _Alloc(__a), _M_fn(std::forward<_Fn2>(__fn)) { } _Fn _M_fn; } _M_impl; }; template> static shared_ptr<__future_base::_Task_state_base<_Signature>> __create_task_state(_Fn&& __fn, const _Alloc& __a = _Alloc()) { typedef typename decay<_Fn>::type _Fn2; typedef __future_base::_Task_state<_Fn2, _Alloc, _Signature> _State; return std::allocate_shared<_State>(__a, std::forward<_Fn>(__fn), __a); } template shared_ptr<__future_base::_Task_state_base<_Res(_Args...)>> __future_base::_Task_state<_Fn, _Alloc, _Res(_Args...)>::_M_reset() { return __create_task_state<_Res(_Args...)>(std::move(_M_impl._M_fn), static_cast<_Alloc&>(_M_impl)); } template class packaged_task<_Res(_ArgTypes...)> { typedef __future_base::_Task_state_base<_Res(_ArgTypes...)> _State_type; shared_ptr<_State_type> _M_state; template> using __not_same = typename enable_if::value>::type; public: packaged_task() noexcept { } template> explicit packaged_task(_Fn&& __fn) : _M_state( __create_task_state<_Res(_ArgTypes...)>(std::forward<_Fn>(__fn))) { } # 1530 "/usr/include/c++/10/future" 3 ~packaged_task() { if (static_cast(_M_state) && !_M_state.unique()) _M_state->_M_break_promise(std::move(_M_state->_M_result)); } packaged_task(const packaged_task&) = delete; packaged_task& operator=(const packaged_task&) = delete; packaged_task(packaged_task&& __other) noexcept { this->swap(__other); } packaged_task& operator=(packaged_task&& __other) noexcept { packaged_task(std::move(__other)).swap(*this); return *this; } void swap(packaged_task& __other) noexcept { _M_state.swap(__other._M_state); } bool valid() const noexcept { return static_cast(_M_state); } future<_Res> get_future() { return future<_Res>(_M_state); } void operator()(_ArgTypes... __args) { __future_base::_State_base::_S_check(_M_state); _M_state->_M_run(std::forward<_ArgTypes>(__args)...); } void make_ready_at_thread_exit(_ArgTypes... __args) { __future_base::_State_base::_S_check(_M_state); _M_state->_M_run_delayed(std::forward<_ArgTypes>(__args)..., _M_state); } void reset() { __future_base::_State_base::_S_check(_M_state); packaged_task __tmp; __tmp._M_state = _M_state; _M_state = _M_state->_M_reset(); } }; template inline void swap(packaged_task<_Res(_ArgTypes...)>& __x, packaged_task<_Res(_ArgTypes...)>& __y) noexcept { __x.swap(__y); } # 1605 "/usr/include/c++/10/future" 3 template class __future_base::_Deferred_state final : public __future_base::_State_base { public: explicit _Deferred_state(_BoundFn&& __fn) : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)) { } private: typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; _Ptr_type _M_result; _BoundFn _M_fn; virtual void _M_complete_async() { _M_set_result(_S_task_setter(_M_result, _M_fn), true); } virtual bool _M_is_deferred_future() const { return true; } }; class __future_base::_Async_state_commonV2 : public __future_base::_State_base { protected: ~_Async_state_commonV2() = default; # 1660 "/usr/include/c++/10/future" 3 virtual void _M_complete_async() { _M_join(); } void _M_join() { std::call_once(_M_once, &thread::join, &_M_thread); } thread _M_thread; once_flag _M_once; }; template class __future_base::_Async_state_impl final : public __future_base::_Async_state_commonV2 { public: explicit _Async_state_impl(_BoundFn&& __fn) : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)) { _M_thread = std::thread{ [this] { try { _M_set_result(_S_task_setter(_M_result, _M_fn)); } catch(const __cxxabiv1::__forced_unwind&) { if (static_cast(_M_result)) this->_M_break_promise(std::move(_M_result)); throw; } } }; } ~_Async_state_impl() { if (_M_thread.joinable()) _M_thread.join(); } private: typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type; _Ptr_type _M_result; _BoundFn _M_fn; }; template inline std::shared_ptr<__future_base::_State_base> __future_base::_S_make_deferred_state(_BoundFn&& __fn) { typedef typename remove_reference<_BoundFn>::type __fn_type; typedef _Deferred_state<__fn_type> __state_type; return std::make_shared<__state_type>(std::move(__fn)); } template inline std::shared_ptr<__future_base::_State_base> __future_base::_S_make_async_state(_BoundFn&& __fn) { typedef typename remove_reference<_BoundFn>::type __fn_type; typedef _Async_state_impl<__fn_type> __state_type; return std::make_shared<__state_type>(std::move(__fn)); } template [[__nodiscard__]] future<__async_result_of<_Fn, _Args...>> async(launch __policy, _Fn&& __fn, _Args&&... __args) { std::shared_ptr<__future_base::_State_base> __state; if ((__policy & launch::async) == launch::async) { try { __state = __future_base::_S_make_async_state( std::thread::__make_invoker(std::forward<_Fn>(__fn), std::forward<_Args>(__args)...) ); } catch(const system_error& __e) { if (__e.code() != errc::resource_unavailable_try_again || (__policy & launch::deferred) != launch::deferred) throw; } } if (!__state) { __state = __future_base::_S_make_deferred_state( std::thread::__make_invoker(std::forward<_Fn>(__fn), std::forward<_Args>(__args)...)); } return future<__async_result_of<_Fn, _Args...>>(__state); } template [[__nodiscard__]] inline future<__async_result_of<_Fn, _Args...>> async(_Fn&& __fn, _Args&&... __args) { return std::async(launch::async|launch::deferred, std::forward<_Fn>(__fn), std::forward<_Args>(__args)...); } } # 102 "all-std.cxx" 2 # 1 "/usr/include/assert.h" 1 3 4 # 109 "all-std.cxx" 2 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/limits.h" 1 3 4 # 115 "all-std.cxx" 2 # 1 "/usr/include/c++/10/math.h" 1 3 # 36 "/usr/include/c++/10/math.h" 3 # 1 "/usr/include/c++/10/cmath" 1 3 # 39 "/usr/include/c++/10/cmath" 3 # 40 "/usr/include/c++/10/cmath" 3 # 37 "/usr/include/c++/10/math.h" 2 3 using std::abs; using std::acos; using std::asin; using std::atan; using std::atan2; using std::cos; using std::sin; using std::tan; using std::cosh; using std::sinh; using std::tanh; using std::exp; using std::frexp; using std::ldexp; using std::log; using std::log10; using std::modf; using std::pow; using std::sqrt; using std::ceil; using std::fabs; using std::floor; using std::fmod; using std::fpclassify; using std::isfinite; using std::isinf; using std::isnan; using std::isnormal; using std::signbit; using std::isgreater; using std::isgreaterequal; using std::isless; using std::islessequal; using std::islessgreater; using std::isunordered; using std::acosh; using std::asinh; using std::atanh; using std::cbrt; using std::copysign; using std::erf; using std::erfc; using std::exp2; using std::expm1; using std::fdim; using std::fma; using std::fmax; using std::fmin; using std::hypot; using std::ilogb; using std::lgamma; using std::llrint; using std::llround; using std::log1p; using std::log2; using std::logb; using std::lrint; using std::lround; using std::nearbyint; using std::nextafter; using std::nexttoward; using std::remainder; using std::remquo; using std::rint; using std::round; using std::scalbln; using std::scalbn; using std::tgamma; using std::trunc; # 183 "/usr/include/c++/10/math.h" 3 using std::lerp; # 117 "all-std.cxx" 2 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stddef.h" 1 3 4 # 121 "all-std.cxx" 2 # 1 "/usr/include/c++/10/stdlib.h" 1 3 # 36 "/usr/include/c++/10/stdlib.h" 3 # 1 "/usr/include/c++/10/cstdlib" 1 3 # 39 "/usr/include/c++/10/cstdlib" 3 # 40 "/usr/include/c++/10/cstdlib" 3 # 37 "/usr/include/c++/10/stdlib.h" 2 3 using std::abort; using std::atexit; using std::exit; using std::at_quick_exit; using std::quick_exit; using std::div_t; using std::ldiv_t; using std::abs; using std::atof; using std::atoi; using std::atol; using std::bsearch; using std::calloc; using std::div; using std::free; using std::getenv; using std::labs; using std::ldiv; using std::malloc; using std::mblen; using std::mbstowcs; using std::mbtowc; using std::qsort; using std::rand; using std::realloc; using std::srand; using std::strtod; using std::strtol; using std::strtoul; using std::system; using std::wcstombs; using std::wctomb; # 124 "all-std.cxx" 2 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdatomic.h" 1 3 4 # 29 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdatomic.h" 3 4 typedef enum { memory_order_relaxed = 0, memory_order_consume = 1, memory_order_acquire = 2, memory_order_release = 3, memory_order_acq_rel = 4, memory_order_seq_cst = 5 } memory_order; typedef _Atomic _Bool atomic_bool; typedef _Atomic char atomic_char; typedef _Atomic signed char atomic_schar; typedef _Atomic unsigned char atomic_uchar; typedef _Atomic short atomic_short; typedef _Atomic unsigned short atomic_ushort; typedef _Atomic int atomic_int; typedef _Atomic unsigned int atomic_uint; typedef _Atomic long atomic_long; typedef _Atomic unsigned long atomic_ulong; typedef _Atomic long long atomic_llong; typedef _Atomic unsigned long long atomic_ullong; typedef _Atomic short unsigned int atomic_char16_t; typedef _Atomic unsigned int atomic_char32_t; typedef _Atomic int atomic_wchar_t; typedef _Atomic signed char atomic_int_least8_t; typedef _Atomic unsigned char atomic_uint_least8_t; typedef _Atomic short int atomic_int_least16_t; typedef _Atomic short unsigned int atomic_uint_least16_t; typedef _Atomic int atomic_int_least32_t; typedef _Atomic unsigned int atomic_uint_least32_t; typedef _Atomic long int atomic_int_least64_t; typedef _Atomic long unsigned int atomic_uint_least64_t; typedef _Atomic signed char atomic_int_fast8_t; typedef _Atomic unsigned char atomic_uint_fast8_t; typedef _Atomic long int atomic_int_fast16_t; typedef _Atomic long unsigned int atomic_uint_fast16_t; typedef _Atomic long int atomic_int_fast32_t; typedef _Atomic long unsigned int atomic_uint_fast32_t; typedef _Atomic long int atomic_int_fast64_t; typedef _Atomic long unsigned int atomic_uint_fast64_t; typedef _Atomic long int atomic_intptr_t; typedef _Atomic long unsigned int atomic_uintptr_t; typedef _Atomic long unsigned int atomic_size_t; typedef _Atomic long int atomic_ptrdiff_t; typedef _Atomic long int atomic_intmax_t; typedef _Atomic long unsigned int atomic_uintmax_t; # 92 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdatomic.h" 3 4 extern void atomic_thread_fence (memory_order); extern void atomic_signal_fence (memory_order); # 218 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdatomic.h" 3 4 typedef _Atomic struct { _Bool __val; } atomic_flag; extern _Bool atomic_flag_test_and_set (volatile atomic_flag *); extern _Bool atomic_flag_test_and_set_explicit (volatile atomic_flag *, memory_order); extern void atomic_flag_clear (volatile atomic_flag *); extern void atomic_flag_clear_explicit (volatile atomic_flag *, memory_order); # 130 "all-std.cxx" 2 # 1 "/usr/include/c++/10/complex.h" 1 3 # 32 "/usr/include/c++/10/complex.h" 3 # 1 "/usr/include/c++/10/ccomplex" 1 3 # 29 "/usr/include/c++/10/ccomplex" 3 # 30 "/usr/include/c++/10/ccomplex" 3 # 38 "/usr/include/c++/10/ccomplex" 3 extern "C++" { } # 33 "/usr/include/c++/10/complex.h" 2 3 # 131 "all-std.cxx" 2 # 1 "/usr/include/c++/10/tgmath.h" 1 3 # 32 "/usr/include/c++/10/tgmath.h" 3 # 1 "/usr/include/c++/10/ctgmath" 1 3 # 29 "/usr/include/c++/10/ctgmath" 3 # 30 "/usr/include/c++/10/ctgmath" 3 # 1 "/usr/include/c++/10/cmath" 1 3 # 39 "/usr/include/c++/10/cmath" 3 # 40 "/usr/include/c++/10/cmath" 3 # 38 "/usr/include/c++/10/ctgmath" 2 3 extern "C++" { } # 33 "/usr/include/c++/10/tgmath.h" 2 3 # 132 "all-std.cxx" 2 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/iso646.h" 1 3 4 # 133 "all-std.cxx" 2 # 1 "/usr/lib/gcc/x86_64-linux-gnu/10/include/stdbool.h" 1 3 4 # 134 "all-std.cxx" 2